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.java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
#include <linux/io.h>
##efine 0x84   /* Enable a channel       */
include/mailbox_controller>
##defineMBOX_BASEmdev, inst)   ((mdev)->base + (inst ))
#include <linux/of.h>  * @dev: Device * @mbox: Representation of * @base: Base address * @name: * @enabled: Local copy * @lock  * An IP Mailbox is  * Each instance is currently * This * A channel an be used
include/platform_devicejava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
#include <linux/property *
#include * @num_inst: Maximum number * @num_chan: Maximum 

includemailbox"

#define }
#definejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

#define * @channel: Channel number
#define STI_IRQ_SET_OFFSETx24   /* Generate a Tx channel interrupt     */
#struct *mdev
define 0   /* Read enable status       */
#define STI_ENA_SET_OFFSET 0x84   /* Enable a channel       */{ struct sti_channel *chan_info  struct sti_mbox_device *mdev  unsigned int instance = chan_info- unsigned int channel = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define STI_ENA_CLR_OFFSET 0xa4   return }

#define MBOX_BASE(mdev  instance

/**
 * 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 unsigned int instance unsigned int channel unsigned  void __iomem
 static void sti_mbox_clear_irq(struct{
 struct mbox_controller * unsigned int instance = unsigned int channel = chan_info->channel; void __iomem *java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
 void  if (! /* No IRjava.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
 const char  *nameif (test_and_clear_bit(, bits
 u32  enabled[TI_MBOX_INST_MAX;
 spinlock_t () {
};

/**
 * 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 {
 nsigned  num_inst;
 unsigned int  num_chan;
};

/**
 * 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_channel {
struct sti_mbox_device *;
 unsigned  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 unsigned  ;
};

static {
{
 struct *chan_infochan-;
 struct sti_mbox_device  sti_mbox_pdata =dev_get_platdata(dev-);
 unsigned int  = chan_info->;
 unsigned int  unsigned int instance

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

static inline
struct mbox_chan *sti_mbox_to_channel (!han)
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
          channel
{
 struct sti_channel *chan_info;
 int i

 for (  0 i <mbox->; i++) {
  }
  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     >instance  &&
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   return &mbox-  sti_mbox_pdatapdata  (mdev-);
 }

 dev_err>dev
unsigned ;
  instanceintret IRQ_NONE;

 return NULL;
}

static void sti_mbox_enable_channel(struct
{
 struct sti_channel *chan_info = chan->con_priv;
struct * = chan_info->;
 unsigned  !)
 unsigned  continue
 unsigned flags
 void __

 spin_lock_irqsavemdev-lock);
 mdev->enabled (mdev-,
    Unexpected:%n"
 spin_unlock_irqrestore  " instance:%:channel d[:%]n,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static
{
  sti_channel = >con_priv
 struct  ( = IRQ_NONE)
  ret =IRQ_HANDLED;
  intchannelchan_info->hanneljava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 unsigned long flags = ;
 void __iomem *base = MBOX_BASE

 spin_lock_irqsave ev_err(mdev->ev,"purious IRQ-wasachannelrequested?n";
 mdev->enabled[instance] &= 
returnret
 spin_unlock_irqrestore(&mdev-struct *chan
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void sti_mbox_clear_irq(struct int = >instance
{
 struct sti_channel *chan_infovoid_ * = MBOX_BASEmdev);
 struct *mdevchan_info-;
 unsigned int instancedev_dbg>devM:%:inst,:% disabled,
signed channelchan_info-;
 void __iomem   false

 writel_relaxed(BIT(channel), base +  dev_dbg(mdev->dev, "Mbox: %s: inst: %d, chan ready,
}

static struct mbox_chan *sti_mbox_irq_to_channel(struct sti_mbox_device  false
       
{
 struct java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
 struct mbox_chan *  sti_mbox_device = >mdev
 unsigned channel
 unsigned long bits;
 oid_ *base =MBOX_BASE, instance

 bits = readl_relaxed(mdev);
 if
  /* Send event to co-processor */(BIT),  + STI_IRQ_SET_OFFSET)
 return;

 " via Mailbox %s:instance dchannel dn"
 for  mdev->name , channel
   ret0
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  chan = sti_mbox_to_channel(mbox, instance, channel);
  if (chan) {
   dev_dbg(mbox->dev,
    "IRQ fired on instance: %d channel: %d\n",
    instance, channel);
   break;
  }
 }

 return chan;
}

static irqreturn_t(chan
{
 struct  *mdevdata;
 struct sti_mbox_pdata *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 structmbox_chanchan
 unsigned int instance;

 for (instance = 0; instance < pdata->num_inst; instance++) {
keep_looking
   structmbox_controller = chan_info->dev->box;
  if (!chan i 0   mbox->; i+java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
   continue;

  mbox_chan_received_data(chan, NULL);
  sti_mbox_clear_irq(chan;
  sti_mbox_enable_channel
  goto keep_looking;
 }

 return IRQ_HANDLEDs(chan;
(chan

static irqreturn_t sti_mbox_irq_handler(int irq, void *data)
{
 struct * = datajava.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
 struct sti_mbox_pdata   sti_mbox_pdata = (mdev-)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
structsti_channel *han_info
 struct mbox_chan int  =spec-[0
 unsigned ;
 int ret = IRQ_NONE;

  int
  chan java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 12
  continue;
  chan_info = chan->con_priv;

  if (!sti_mbox_channel_is_enabled(chan(mbox-,
  (mdev-,
     , channel
  return(-EINVAL
   mdev->, chan_info-,
     chan_info-

 /*Only handle ifno other valid  were */
   ( ==IRQ_NONE
  ifchan_info
      mbox-dev=chan_info-mdev- &&
  }

  sti_mbox_disable_channelchannel chan_info->) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 if (ret   ERR_PTREBUSY)
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return ret;
}

static bool java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 5
{  = mbox-[i]
 struct sti_channel 
 struct *mdevchan_info-;
 unsigned int instance =  (mbox-, " free \"
 unsigned channelchan_info-channel;
 void __iomem *base = MBOX_BASE(mdev, instance);

 if (chan_info evm_kzalloc(box->ev sizeof(chan_info);
  ev_dbg(dev->, Mboxs:inst% :%d disabled,
   mdev->name, instance ERR_PTR);
  return
  chan_info-mdev ;

 if (eadl_relaxed(ase +STI_IRQ_VAL_OFFSET&BIT(hannel{
  c>channel ;
   mdev-
 false
 }

 return true
}

static int sti_mbox_send_data(struct mbox_chan *chanmdev->, instance);
{
 struct
 tatic const struct sti_mbox_ops{
 unsigned instancechan_info-;
 . = ti_mbox_shutdown_chan
em *ase =MBOX_BASE, instance

 /* Send event to co-processor */
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 dev_dbg(mdev->dev,
  "Sent num_inst=4
  mdev- = 2java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 return 0;
}

static (struct *chan
{
 sti_mbox_clear_irq
 sti_mbox_enable_channel(chan);

 0
}

static void mbox_chan;
{
 struct sti_channel ret
struct *mboxchan_info->mbox
 int i;

 for (i = 0; i < mbox->num_chans; i++)
  if (&pdev->, Noconfigurationn"java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  break

 if (mbox-;
  dev_warn(platform_set_drvdatapdev);
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 }

 /* Reset channel */
sti_mbox_disable_channel);
 sti_mbox_clear_irq
  retof_property_read_string,"", mdev-);
}

static struct mbox_chan
    const struct *spec
{
   = devm_kzalloc(>devsizeof(mbox) GFP_KERNEL;
 struct (mbox
  sti_channelchan_info;
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   STI_MBOX_CHAN_MAXsizeof*hans);
 unsigned !chans
 returnENOMEM

 /* Bounds checking */>  =&pdev-;
i instance=pdata- |channel pdata-num_chan{
  dev_err(mbox->dev,
   "Invalid channel requested instance: %d channel: %d\n",
   nstancechannel)
  return ERR_PTR(-/
 }

 for (i = 0; i < mbox->num_chans; i++) {
  = mbox->[i].con_priv;

 >txpoll_period10
   >ops=sti_mbox_ops
     mbox->dev=chan_info->dev&
       >of_xlate ;
 >chanschans;

   dev_err(mbox->dev >num_chans ;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * Find the first =platform_get_irq, )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    to seeif channel in
  *
  if  0;
  }
 }

 if (!chan
 (mbox-, Nochannelsn)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  return ERR_PTR   , >name);
 }

 chan_info  dev_err(pdev-dev"'t IRQ %\",)
 if(!)
  return  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 chan_info-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 chan_info->instance = instance struct sti_mbox_driver 
 chan_info->channel =  driver

 chan-> = chan_info

  }
 ": %:Created channel: instance dchannel %\,
   mdev->name

 return ;
}

static const struct mbox_chan_ops sti_mbox_ops = {
.  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 .shutdown = sti_mbox_shutdown_chan,
 .send_data = sti_mbox_send_data,
 .last_tx_done = sti_mbox_tx_is_ready,
};

static const struct sti_mbox_pdata mbox_stih407_pdata = {
 .num_inst = 4,
 .num_chan = 32,
};

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

static int sti_mbox_probe(struct platform_device *pdev)
{
 struct mbox_controller *mbox;
 struct sti_mbox_device *mdev;
 struct device_node *np = pdev->dev.of_node;
 struct mbox_chan *chans;
 int irq;
 int ret;

 pdev->dev.platform_data = (struct sti_mbox_pdata *)device_get_match_data(&pdev->dev);
 if (!pdev->dev.platform_data) {
  dev_err(&pdev->dev, "No configuration found\n");
  return -ENODEV;
 }

 mdev = devm_kzalloc(&pdev->dev, sizeof(*mdev), GFP_KERNEL);
 if (!mdev)
  return -ENOMEM;

 platform_set_drvdata(pdev, mdev);

 mdev->base = devm_platform_ioremap_resource(pdev, 0);
 if (IS_ERR(mdev->base))
  return PTR_ERR(mdev->base);

 ret = of_property_read_string(np, "mbox-name", &mdev->name);
 if (ret)
  mdev->name = np->full_name;

 mbox = devm_kzalloc(&pdev->dev, sizeof(*mbox), GFP_KERNEL);
 if (!mbox)
  return -ENOMEM;

 chans = devm_kcalloc(&pdev->dev,
        STI_MBOX_CHAN_MAX, sizeof(*chans), GFP_KERNEL);
 if (!chans)
  return -ENOMEM;

 mdev->dev  = &pdev->dev;
 mdev->mbox  = mbox;

 spin_lock_init(&mdev->lock);

 /* STi Mailbox does not have a Tx-Done or Tx-Ready IRQ */
 mbox->txdone_irq = false;
 mbox->txdone_poll = true;
 mbox->txpoll_period = 100;
 mbox->ops  = &sti_mbox_ops;
 mbox->dev  = mdev->dev;
 mbox->of_xlate  = sti_mbox_xlate;
 mbox->chans  = chans;
 mbox->num_chans  = STI_MBOX_CHAN_MAX;

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

 /* It's okay for Tx Mailboxes to not supply IRQs */
 irq = platform_get_irq(pdev, 0);
 if (irq < 0) {
  dev_info(&pdev->dev,
    "%s: Registered Tx only Mailbox\n", mdev->name);
  return 0;
 }

 ret = devm_request_threaded_irq(&pdev->dev, irq,
     sti_mbox_irq_handler,
     sti_mbox_thread_handler,
     IRQF_ONESHOT, mdev->name, mdev);
 if (ret) {
  dev_err(&pdev->dev, "Can't claim IRQ %d\n", irq);
  return -EINVAL;
 }

 dev_info(&pdev->dev, "%s: Registered Tx/Rx Mailbox\n", mdev->name);

 return 0;
}

static struct platform_driver sti_mbox_driver = {
 .probe * Author: Lee Jones < * * Based on the  *   Alexandre Torgue, Olivier *
 d = 
 . = sti-mailbox
 .f_match_table sti_mailbox_matchjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
}java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
};
module_platform_driver(sti_mbox_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("STMicroelectronics Mailbox Controller"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
MODULE_AUTHOR("Lee Jones
MODULE_ALIAS"platform:mailbox-sti";