linux/drivers/remoteproc/omap_remoteproc.c
<<
>>
Prefs
   1/*
   2 * OMAP Remote Processor driver
   3 *
   4 * Copyright (C) 2011 Texas Instruments, Inc.
   5 * Copyright (C) 2011 Google, Inc.
   6 *
   7 * Ohad Ben-Cohen <ohad@wizery.com>
   8 * Brian Swetland <swetland@google.com>
   9 * Fernando Guzman Lugo <fernando.lugo@ti.com>
  10 * Mark Grosen <mgrosen@ti.com>
  11 * Suman Anna <s-anna@ti.com>
  12 * Hari Kanigeri <h-kanigeri2@ti.com>
  13 *
  14 * This program is free software; you can redistribute it and/or
  15 * modify it under the terms of the GNU General Public License
  16 * version 2 as published by the Free Software Foundation.
  17 *
  18 * This program is distributed in the hope that it will be useful,
  19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 * GNU General Public License for more details.
  22 */
  23
  24#include <linux/kernel.h>
  25#include <linux/module.h>
  26#include <linux/err.h>
  27#include <linux/platform_device.h>
  28#include <linux/dma-mapping.h>
  29#include <linux/remoteproc.h>
  30
  31#include <plat/mailbox.h>
  32#include <linux/platform_data/remoteproc-omap.h>
  33
  34#include "omap_remoteproc.h"
  35#include "remoteproc_internal.h"
  36
  37/**
  38 * struct omap_rproc - omap remote processor state
  39 * @mbox: omap mailbox handle
  40 * @nb: notifier block that will be invoked on inbound mailbox messages
  41 * @rproc: rproc handle
  42 */
  43struct omap_rproc {
  44        struct omap_mbox *mbox;
  45        struct notifier_block nb;
  46        struct rproc *rproc;
  47};
  48
  49/**
  50 * omap_rproc_mbox_callback() - inbound mailbox message handler
  51 * @this: notifier block
  52 * @index: unused
  53 * @data: mailbox payload
  54 *
  55 * This handler is invoked by omap's mailbox driver whenever a mailbox
  56 * message is received. Usually, the mailbox payload simply contains
  57 * the index of the virtqueue that is kicked by the remote processor,
  58 * and we let remoteproc core handle it.
  59 *
  60 * In addition to virtqueue indices, we also have some out-of-band values
  61 * that indicates different events. Those values are deliberately very
  62 * big so they don't coincide with virtqueue indices.
  63 */
  64static int omap_rproc_mbox_callback(struct notifier_block *this,
  65                                        unsigned long index, void *data)
  66{
  67        mbox_msg_t msg = (mbox_msg_t) data;
  68        struct omap_rproc *oproc = container_of(this, struct omap_rproc, nb);
  69        struct device *dev = oproc->rproc->dev.parent;
  70        const char *name = oproc->rproc->name;
  71
  72        dev_dbg(dev, "mbox msg: 0x%x\n", msg);
  73
  74        switch (msg) {
  75        case RP_MBOX_CRASH:
  76                /* just log this for now. later, we'll also do recovery */
  77                dev_err(dev, "omap rproc %s crashed\n", name);
  78                break;
  79        case RP_MBOX_ECHO_REPLY:
  80                dev_info(dev, "received echo reply from %s\n", name);
  81                break;
  82        default:
  83                /* msg contains the index of the triggered vring */
  84                if (rproc_vq_interrupt(oproc->rproc, msg) == IRQ_NONE)
  85                        dev_dbg(dev, "no message was found in vqid %d\n", msg);
  86        }
  87
  88        return NOTIFY_DONE;
  89}
  90
  91/* kick a virtqueue */
  92static void omap_rproc_kick(struct rproc *rproc, int vqid)
  93{
  94        struct omap_rproc *oproc = rproc->priv;
  95        struct device *dev = rproc->dev.parent;
  96        int ret;
  97
  98        /* send the index of the triggered virtqueue in the mailbox payload */
  99        ret = omap_mbox_msg_send(oproc->mbox, vqid);
 100        if (ret)
 101                dev_err(dev, "omap_mbox_msg_send failed: %d\n", ret);
 102}
 103
 104/*
 105 * Power up the remote processor.
 106 *
 107 * This function will be invoked only after the firmware for this rproc
 108 * was loaded, parsed successfully, and all of its resource requirements
 109 * were met.
 110 */
 111static int omap_rproc_start(struct rproc *rproc)
 112{
 113        struct omap_rproc *oproc = rproc->priv;
 114        struct device *dev = rproc->dev.parent;
 115        struct platform_device *pdev = to_platform_device(dev);
 116        struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
 117        int ret;
 118
 119        if (pdata->set_bootaddr)
 120                pdata->set_bootaddr(rproc->bootaddr);
 121
 122        oproc->nb.notifier_call = omap_rproc_mbox_callback;
 123
 124        /* every omap rproc is assigned a mailbox instance for messaging */
 125        oproc->mbox = omap_mbox_get(pdata->mbox_name, &oproc->nb);
 126        if (IS_ERR(oproc->mbox)) {
 127                ret = PTR_ERR(oproc->mbox);
 128                dev_err(dev, "omap_mbox_get failed: %d\n", ret);
 129                return ret;
 130        }
 131
 132        /*
 133         * Ping the remote processor. this is only for sanity-sake;
 134         * there is no functional effect whatsoever.
 135         *
 136         * Note that the reply will _not_ arrive immediately: this message
 137         * will wait in the mailbox fifo until the remote processor is booted.
 138         */
 139        ret = omap_mbox_msg_send(oproc->mbox, RP_MBOX_ECHO_REQUEST);
 140        if (ret) {
 141                dev_err(dev, "omap_mbox_get failed: %d\n", ret);
 142                goto put_mbox;
 143        }
 144
 145        ret = pdata->device_enable(pdev);
 146        if (ret) {
 147                dev_err(dev, "omap_device_enable failed: %d\n", ret);
 148                goto put_mbox;
 149        }
 150
 151        return 0;
 152
 153put_mbox:
 154        omap_mbox_put(oproc->mbox, &oproc->nb);
 155        return ret;
 156}
 157
 158/* power off the remote processor */
 159static int omap_rproc_stop(struct rproc *rproc)
 160{
 161        struct device *dev = rproc->dev.parent;
 162        struct platform_device *pdev = to_platform_device(dev);
 163        struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
 164        struct omap_rproc *oproc = rproc->priv;
 165        int ret;
 166
 167        ret = pdata->device_shutdown(pdev);
 168        if (ret)
 169                return ret;
 170
 171        omap_mbox_put(oproc->mbox, &oproc->nb);
 172
 173        return 0;
 174}
 175
 176static struct rproc_ops omap_rproc_ops = {
 177        .start          = omap_rproc_start,
 178        .stop           = omap_rproc_stop,
 179        .kick           = omap_rproc_kick,
 180};
 181
 182static int omap_rproc_probe(struct platform_device *pdev)
 183{
 184        struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
 185        struct omap_rproc *oproc;
 186        struct rproc *rproc;
 187        int ret;
 188
 189        ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
 190        if (ret) {
 191                dev_err(&pdev->dev, "dma_set_coherent_mask: %d\n", ret);
 192                return ret;
 193        }
 194
 195        rproc = rproc_alloc(&pdev->dev, pdata->name, &omap_rproc_ops,
 196                                pdata->firmware, sizeof(*oproc));
 197        if (!rproc)
 198                return -ENOMEM;
 199
 200        oproc = rproc->priv;
 201        oproc->rproc = rproc;
 202
 203        platform_set_drvdata(pdev, rproc);
 204
 205        ret = rproc_add(rproc);
 206        if (ret)
 207                goto free_rproc;
 208
 209        return 0;
 210
 211free_rproc:
 212        rproc_put(rproc);
 213        return ret;
 214}
 215
 216static int omap_rproc_remove(struct platform_device *pdev)
 217{
 218        struct rproc *rproc = platform_get_drvdata(pdev);
 219
 220        rproc_del(rproc);
 221        rproc_put(rproc);
 222
 223        return 0;
 224}
 225
 226static struct platform_driver omap_rproc_driver = {
 227        .probe = omap_rproc_probe,
 228        .remove = omap_rproc_remove,
 229        .driver = {
 230                .name = "omap-rproc",
 231                .owner = THIS_MODULE,
 232        },
 233};
 234
 235module_platform_driver(omap_rproc_driver);
 236
 237MODULE_LICENSE("GPL v2");
 238MODULE_DESCRIPTION("OMAP Remote Processor control driver");
 239
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.