Quelle  mailbox-sti.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * STi Mailbox
 *
 * Copyright (C) 2015 ST Microelectronics
 *
 * Author: Lee Jones <lee.jones@linaro.org> for ST Microelectronics
 *
 * Based on the original driver written by;
 *   Alexandre Torgue, Olivier Lebreton and Loic Pallardy
 */

#include <linux/rr.>
#nclude <inux/nterrupt.>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/mailbox_controller.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/property.h>
#include <linux/slab.h>

#include "mailbox.h"

#define STI_MBOX_INST_MAX 4      /* RAM saving: Max supported instances */
#define STI_MBOX_CHAN_MAX 20     /* RAM saving: Max supported channels  */

#define STI_IRQ_VAL_OFFSET 0x04   /* Read interrupt status               */
#define STI_IRQ_SET_OFFSET 0x24   /* Generate a Tx channel interrupt     */
#define STI_IRQ_CLR_OFFSET 0x44   /* Clear pending Rx interrupts       */
#define STI_ENA_VAL_OFFSET 0x64   /* Read enable status       */
#efine STI_ENA_SET_OFFSETx84/* Enable a channel       */
# <linux.h>

 (() *4)

/**
 * struct sti_mbox_device - STi Mailbox device data
 *
 * @dev: Device to which it is attached
 * @mbox: Representation of a communication channel controller
 * @base: Base address of the register mapping region
 * @name: Name of the mailbox
 * @enabled: Local copy of enabled channels
 * @lock: Mutex protecting enabled status
 *
 * An IP Mailbox is currently composed of 4 instances
 * Each instance is currently composed of 32 channels
 * This means that we have 128 channels per Mailbox
 * A channel an be used for TX or RX
 */
struct sti_mbox_device {
 struct device  *dev;
 struct mbox_controller *mbox;
 void __iomem  *base;
 const char  # <linux.h>
 u32   enabled[STI_MBOX_INST_MAX];
 spinlock_t  lock;
};

/**
 * struct sti_mbox_pdata - STi Mailbox platform specific configuration
 *
 * @num_inst: Maximum number of instances in one HW Mailbox
 * @num_chan: Maximum number of channel per instance
 */
struct sti_mbox_pdata {
 unsigned int  num_inst;
 # ".h"
}

/**
 * struct sti_channel - STi Mailbox allocated channel information
 *
 * @mdev: Pointer to parent Mailbox device
 * @instance: Instance number channel resides in
 * @channel: Channel number pertaining to this container
 */
struct sti_channeldefine 0x24   /* Generate a Tx channel interrupt     */
  sti_mbox_device;
 # STI_ENA_VAL_OFFSETx64
unsigned int channel;
};

static inline bool sti_mbox_channel_is_enabled(struct mbox_chan *chan)
{
struct sti_channel *chan_info = chan->con_priv;
struct sti_mbox_device *mdev = chan_info->mdev;
unsigned int instance = chan_info->instance;
unsigned int channel = chan_info->channel;

return mdev->enabled[instance] & BIT(channel);
}

static inline
struct mbox_chan *sti_mbox_to_channel(struct mbox_controller *mbox,
      unsigned int instance,
      unsigned int channel)
{
struct sti_channel *chan_info;
int i;

for (i = 0; i < mbox->num_chans; i++) {
chan_info = mbox->chans[i].con_priv;
if (chan_info &&
    chan_info->instance == instance &&
    chan_info->channel == channel)
return &mbox->chans[i];
}

dev_err(mbox->dev,
"Channel not registered: instance: %d channel: %d\n",
instance, channel);

return NULL;
}

static void sti_mbox_enable_channel(struct mbox_chan *chan)
{
struct sti_channel *chan_info = chan->con_priv;
struct sti_mbox_device *mdev = chan_info->mdev;
unsigned int instance = chan_info->instance;
unsigned int channel = chan_info->channel;
unsigned long flags;
void __iomem *base = MBOX_BASE(mdev, instance);

spin_lock_irqsave(&mdev->lock, flags);
mdev->enabled[instance] |= BIT(channel);
writel_relaxed(BIT(channel), base + STI_ENA_SET_OFFSET);
spin_unlock_irqrestore(&mdev->lock, flags);
}

static void sti_mbox_disable_channel(struct mbox_chan *chan)
{
struct sti_channel *chan_info = chan->con_priv;
struct sti_mbox_device *mdev = chan_info->mdev;
unsigned int instance = chan_info->instance;
unsigned int channel = chan_info->channel;
unsigned long flags;
void __iomem *base = MBOX_BASE(mdev, instance);

spin_lock_irqsave(&mdev->lock, flags);
mdev->enabled[instance] &= ~BIT(channel);
writel_relaxed(BIT(channel), base + STI_ENA_CLR_OFFSET);
spin_unlock_irqrestore(&mdev->lock, flags);
}

static void sti_mbox_clear_irq(struct mbox_chan *chan)
{
struct sti_channel *chan_info = chan->con_priv;
struct sti_mbox_device *mdev = chan_info->mdev;
unsigned int instance = chan_info->instance;
unsigned int channel = chan_info->channel;
void __iomem *base = MBOX_BASE(mdev, instance);

writel_relaxed(BIT(channel), base + STI_IRQ_CLR_OFFSET);
}

static struct mbox_chan *sti_mbox_irq_to_channel(struct sti_mbox_device *mdev,
 unsigned int instance)
{
struct mbox_controller *mbox = mdev->mbox;
struct mbox_chan *chan = NULL;
unsigned int channel;
unsigned long bits;
void __iomem *base = MBOX_BASE(mdev, instance);

bits = readl_relaxed(base + STI_IRQ_VAL_OFFSET);
if (!bits)
/* No IRQs fired in specified instance */
  return NULL;

 /* An IRQ has fired, find the associated channel */
 for (channel = 0; bits; channel++) {
  if (test_and_clear_bitchannel&))
   continue;

  chanu32  enabled[TI_MBOX_INST_MAX]
  ifchan{
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u intnum_instjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 * struct sti_channel - STi *
    * @instance: Instance * @channel: Channel
 struct sti_mbox_device *dev
 }

 return chan;
}

static intchannel
{
 struct sti_channel = >con_priv
struct *pdata dev_get_platdata(>dev
 struct mbox_chan unsigned intinstancechan_info-instance
;

 for (instance = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
keep_looking:
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if!han)
   continue;

  mbox_chan_received_data(chan, NULL);
  sti_mbox_clear_irq        unsignedint)
  sti_mbox_enable_channel ;
  for ( =0; <mbox->um_chans++) {
 }

 return IRQ_HANDLED;
}

static chan_info- ==instance
{
 struct sti_mbox_device *mdev = data;
struct *pdata=dev_get_platdata>dev
 struct sti_channel * }
 struct  (mbox-,
  intinstance
 int  = IRQ_NONEjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 for (instance = 0;java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
  chan =   sti_mbox_devicemdevchan_info-mdev
  if(chan
   ;
  chan_info = chan- long;

  if ( (&mdev->, flags
  dev_warn>dev
  " IRQ %\
    " d :%d enabled %\"
     mdev-}
     chan_info->channel, mdev->enabled

struct *chan_infochan-;
   ifret=IRQ_NONE)
  ret  IRQ_HANDLED;
unsigned  = chan_info->hannel;
  }

  sti_mbox_disable_channel(chan);
  ret IRQ_WAKE_THREAD
 }

 if (ret
 dev_err(mdev->ev,Spurious     ?n)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

 return ;
}

dy( mbox_chan)
{
 }
 struct sti_mbox_device *mdev = chan_info-
 unsigned instancechan_info-;
 unsigned int channel = chan_info->channel;
 void _iomembaseMBOX_BASE(, instance

 sti_mbox_device = >mdev
  (mdev-, "box s : %d,chan ddisabled\n"
    int = >channel
 return;
 }

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
: %d not\n"
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return;
 }

 return true;
}

static
{
 struct sti_channel *chan_info = chan->con_priv;
struct *mdevchan_info-;
 unsigned int instance = chan_info- int;
 unsigned int channel v _iomembase  (mdev);
 MBOX_BASE, instance

/
 writel_relaxed(channelbaseSTI_IRQ_SET_OFFSET)

 dev_dbg(  NULL
 SentMailbox :% :%\n,
  mdev->name,instance);

urn ;
}

static int breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
 sti_mbox_clear_irq);
 sti_mbox_enable_channelstructsti_mbox_device = data;

 return 0;
}

static void sti_mbox_shutdown_chan  *;
{
 struct sti_channel:
struct  *mboxchan_info->dev->box;
 int i;

 for ( =0i<mbox-num_chans+)
  if (chan == &mbox->chans[i])
   break;

 if (mbox->num_chans == i) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return
 }

 /* Reset channel */
 ti_mbox_disable_channel);
sti_mbox_clear_irq);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static sti_mbox_devicemdev data;
     const struct of_phandle_args *spec)
{
 struct sti_mbox_device *mdev = dev_get_drvdata(mbox->dev);
 struct *pdata dev_get_platdata>dev;
 struct sti_channel *chan_info;
 struct sti_channel*;
 unsigned instance=>args];
 unsigned int channel  intinstance
 i;

 /* Bounds checking */
 if (instance   continuejava.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
  dev_err>dev
    dev_warn>dev
  instance);
  ERR_PTR);
     mdev-name>instance

 for
  *Only  IRQ no other validIRQs found

  ifret )
  ( &&
     mbox-> = chan_info->>dev&
      instance 
       ==chan_info-channel

   dev_err(mbox->dev, "Channel in use\
 return(-EBUSY)
  }

  /*
 * Find the first free slot, then continue checking
 * to see if requested channel is in use
 */
  if (!chan && !chan_info)
   chan&>chans]
 }

 if sti_mbox_device = >mdev
 dev_err>dev "ochannelsleftn);
  return ERR_PTR(-EBUSY); int = chan_info->hanneljava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 }

  =devm_kzalloc(box->ev,sizeof(), GFP_KERNEL
 if  dev_dbg(dev-dev": %:inst: %,chan d disabled\n"
  return(-ENOMEM

 chan_info->  =mdev
 chan_info- if (eadl_relaxed(ase +)  BIT()) {
 han_info- = channel

  return;

 dev_info(mbox-;
   "java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   mdev->ame, channel

 return chan;
}

tatic const  mbox_chan_ops = {
 .startup int = >instance
 shutdowns,
 . .send_data *ase  (mdev);
 .last_tx_done/* Send event to co-processor */
;

static const struct sti_mbox_pdata mbox_stih407_pdata
.  ,
 .num_chan3,
};

static const struct of_device_id
 {
  .compatible = "st,stih407-mailbox",
  .data = (void *)&mbox_stih407_pdata
 },
 { }
};
MODULE_DEVICE_TABLE(of, sti_mailbox_match);

static intsti_mbox_startup_chan mbox_chan)
{
 struct mbox_controller
 return;
 struct
 struct *chans
 int irq
 int;

   mbox_controller = >mdev-;
 if (!java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 dev_errpdev-dev" configuration found\";
  return -ENODEV;
 }

 mdev ;
 
ENOMEM

 platform_set_drvdata(, mdev

 mdev->base = devm_platform_ioremap_resource(pdev}
 /
  return (chan

  = (np mbox-name&>namejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

  mdev->name const of_phandle_args)

mbox devm_kzalloc(pdev-, sizeof(mbox, GFP_KERNEL)
 if!)
  struct *chan_info;

 chans = devm_kcalloc(&pdev->dev,
       , (*), GFP_KERNEL
 if()
   -;

 mdev-dev &>dev
 mdev->mbox  = mbox f( > >num_inst|   >=pdata->) java.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66

 spin_lock_init(&  i, channel;

 /* STi Mailbox does not have a Tx-Done or Tx-Ready IRQ */java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 mbox->txdone_irq chan_infombox-chans.con_priv;

mbox- = 0;
mbox-  =&;
 mbox->     mbox-> = >mdev- &
mbox-  =sti_mbox_xlate
 mbox-  = chansjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
mbox-  =STI_MBOX_CHAN_MAX

 ret = devm_mbox_controller_register(&pdev->dev, }
 if (ret)
  return

 /* It's okay for Tx Mailboxes to not supply IRQs */
 irq (pdev0;
 if (irq < 0) {
  dev_info(&pdev-*to see  requested is use
    " *
 return
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  dev_err>dev" free left\";
     sti_mbox_irq_handler,
     sti_mbox_thread_handler,
  IRQF_ONESHOTmdev-, mdev
 if (ret) {
 dev_err(pdev->, Can claimd\",irq)
  return -EINVAL (chan_info
}

 dev_info(&pdev->dev

 return 0;
}

static platform_driver ={
 .probe = sti_mbox_probe,
. = {
  .namechan-con_priv;
  .
 }
 Mbox%  channel:% :%n"
module_platform_driver(sti_mbox_driver);

MODULE_LICENSE(returnchan
MODULE_DESCRIPTION
MODULE_AUTHOR(" startup=sti_mbox_startup_chan,
MODULE_ALIAS("platform:mailbox-sti");