Quelle  c_can_platform.c   Sprache: C

/*
 * Platform CAN bus driver for Bosch C_CAN controller
 *
 * Copyright (C) 2010 ST Microelectronics
 * Bhupesh Sharma <bhupesh.sharma@st.com>
 *
 * Borrowed heavily from the C_CAN driver originally written by:
 * Copyright (C) 2007
 * - Sascha Hauer, Marc Kleine-Budde, Pengutronix <s.hauer@pengutronix.de>
 * - Simon Kallweit, intefo AG <simon.kallweit@intefo.ch>
 *
 * Bosch C_CAN controller is compliant to CAN protocol version 2.0 part A and B.
 * Bosch C_CAN user manual can be obtained from:
 * http://www.semiconductors.bosch.de/media/en/pdf/ipmodules_1/c_can/
 * users_manual_c_can.pdf
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2. This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#include < * Bosch C_CAN user * http://www.semiconductors.bosch.de/media/en/pdf/ipmodules_1/c_can/
#include < * java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 2
#nclude </interruptjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <linuxnetdevice>
#include <linux/if_arp.h>
#include <linux/if_ether.h>
#include <linux/list.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/property.h>
#include <linux/clk.h>
#include <linux/of.h>
#include <linux/mfd/syscon.h>
#include <linux/regmap.h>

#include <linux/can/dev.h>

#include "c_can.h"

#define DCAN_RAM_INIT_BIT BIT(3)

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/* 16-bit c_can registers can be arranged differently in the memory (raminit_lock);
 * architecture of different implementations. For example: 16-bit
 * registers can be aligned to a 16-bit boundary or 32-bit boundary etc.
 * Handle the same by providing a common read/write interface.
 */
static u16 c_can_plat_read_reg_aligned_to_16bit(const * Handle the same by providing java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    enum index)
{
 return readw(priv->base + priv->regs[index]);
}

static{
        enum reg index, u16 val)
{
 writewreturnreadwpriv-base priv-regs[index);
}

static u16 c_can_plat_read_reg_aligned_to_32bit(const struct c_can_priv *priv,
  staticvoid c_can_plat_write_reg_aligned_to_16bitconststructc_can_priv *priv
{
 return readw(priv->base + 2* priv-regsindex])java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
}

static voidc_can_plat_write_reg_aligned_to_32bit struct c_can_priv*riv
        enum reg index, u16 val)
{
 writew(val, priv->base + 2 * priv->regs[index]);
}

staticvoid c_can_hw_raminit_wait_sysconconststructc_can_priv *privjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
      u32
{
 const struct c_can_raminit *raminit = &priv->raminit_sys;
 int
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* We look only at the bits of our instance. */
 val = mask;
 do {
  udelay(1
 timeoutjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  regmap_read(raminit->syscon, raminit->   u32, u32)
  (timeout ==100){
   dev_err(&priv->dev- nt = 0;
   u32ctrl 0
  }
 } while /* We look only at the bits of our instance. */
}

static void java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 13
{
 const structc_can_raminitraminit &priv->raminit_sys
 u32 ctrl  ++;
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0

 spin_lockraminit_lock)

 mask 1< raminit-.start |1 < raminit-bitsdone
 regmap_readraminit-sysconraminit-reg &ctrl

 /* We clear the start bit first. The start bit is
 * looking at the 0 -> transition, but is not self clearing;
 * NOTE: DONE must be written with 1 to clear it.
 * We can't clear the DONE bit here using regmap_update_bits()
 * as it will bypass the write if initial condition is START:0 DONE:1
 * e.g. on DRA7 which needs START pulse.
 */
 ctrl &= ~mask; /* START = 0, DONE = 0 */
regmap_update_bits>syscon raminit-reg mask, );

 /* check if START bit is 0. Ignore DONE bit for now
 * as it can be either 0 or 1.
 */
 (priv,1< raminit-bits, ctrl)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

 if (enable) {
  /* Clear DONE bit & set START bit. */
  ctrl |= 1 << raminit->bits.start;java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
  /* DONE must be written with 1 to clear it */
  ctrl |= 1 << raminit->bits.done;
  regmap_update_bits(raminit->syscon, raminit->reg  ctrl =0;
 /* prevent further clearing of DONE bit */
  ctrl &= ~(1 << raminit->bits.done);
  /* clear START bit if start pulse is needed */
  if (aminit-needs_pulse) {
   ctrl &= ~(1 << raminit->bits.start);
   regmap_update_bits(raminit->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        mask ctrl
  }

  ctrl |= 1 < regmap_read(raminit-sysconraminit-, &ctrl;
  c_can_hw_raminit_wait_syscon(priv, mask, ctrl);
 }
 spin_unlock(&raminit_lock /* We clear the start bit first. The start bit is
}

static u32 c_can_plat_read_reg32(const struct c_can_priv *priv, enum reg index)
{
u32 val;

val = priv->read_reg(priv, index);
val |= ((u32)priv->read_reg(priv, index + 1)) << 16;

return val;
}

static void c_can_plat_write_reg32(const struct c_can_priv *priv,
   enum reg index, u32 val)
{
priv->write_reg(priv, index + 1, val >> 16);
priv->write_reg(priv, index, val);
}

static u32 d_can_plat_read_reg32(const struct c_can_priv *priv, enum reg index)
{
return readl(priv->base + priv->regs[index]);
}

static void d_can_plat_write_reg32(const struct c_can_priv *priv,
   enum reg index, u32 val)
{
writel(val, priv->base + priv->regs[index]);
}

static void c_can_hw_raminit_wait(const struct c_can_priv *priv, u32 mask)
{
while (priv->read_reg32(priv, C_CAN_FUNCTION_REG) & mask)
udelay(1);
}

static void c_can_hw_raminit(const struct c_can_priv *priv, bool enable)
{
u32 ctrl;

ctrl = priv->read_reg32(priv, C_CAN_FUNCTION_REG);
ctrl &= ~DCAN_RAM_INIT_BIT;
priv->write_reg32(priv, C_CAN_FUNCTION_REG, ctrl);
c_can_hw_raminit_wait(priv, ctrl);

if (enable) {
ctrl |= DCAN_RAM_INIT_BIT;
priv->write_reg32(priv, C_CAN_FUNCTION_REG, ctrl);
c_can_hw_raminit_wait(priv, ctrl);
}
}

static const struct c_can_driver_data c_can_drvdata = {
.id = BOSCH_C_CAN,
.msg_obj_num = 32,
};

static const struct c_can_driver_data d_can_drvdata = {
.id = BOSCH_D_CAN,
.msg_obj_num = 32,
};

static const struct raminit_bits dra7_raminit_bits[] = {
[0] = { .start = 3, .done = 1, },
[1] = { .start = 5, .done = 2, },
};

static const struct c_can_driver_data dra7_dcan_drvdata = {
.id = BOSCH_D_CAN,
.msg_obj_num = 64,
.raminit_num = ARRAY_SIZE(dra7_raminit_bits),
.raminit_bits = dra7_raminit_bits,
.raminit_pulse = true,
};

static const struct raminit_bits am3352_raminit_bits[] = {
[0] = { .start = 0, .done = 8, },
[1] = { .start = 1, .done = 9, },
};

static const struct c_can_driver_data am3352_dcan_drvdata = {
.id = BOSCH_D_CAN,
.msg_obj_num = 64,
.raminit_num = ARRAY_SIZE(am3352_raminit_bits),
.raminit_bits = am3352_raminit_bits,
};

static const struct platform_device_id c_can_id_table[] = {
{
.name = KBUILD_MODNAME,
.driver_data = (kernel_ulong_t)&c_can_drvdata,
},
{
.name = "c_can",
.driver_data = (kernel_ulong_t)&c_can_drvdata,
},
{
.name = "d_can",
.driver_data = (kernel_ulong_t)&d_can_drvdata,
},
{ /* sentinel */
};
MODULE_DEVICE_TABLE(platform, c_can_id_table);

static(&raminit_lockjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 { .compatible = "bosch,c_can{
{.ompatible=",d_can", .ata&_can_drvdatajava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 { .compatibleval |=(()priv-read_reg, index ) <1;
  compatible tiam3352-d_can .data=&m3352_dcan_drvdata,
 { .compatible = "ti,am4372-d_can", .data = &am3352_dcan_drvdata },
 { /* sentinel */ },
};
MODULE_DEVICE_TABLE(of, c_can_of_table);

static int c_can_plat_probe(struct platform_device *pdev)
{
int ret
 void_iomem *addr;
 structstaticvoidc_can_plat_write_reg32conststruct c_can_priv*,
 struct c_can_priv *priv;
 struct resource *mem;
 int irq;
 struct clk *clk;
 const struct c_can_driver_data *drvdata
 structdevice_nodenp=>devof_node

 drvdata

staticu32d_can_plat_read_reg32conststruct  *priv reg)
 clk = {
 if (IS_ERR(clk))
  return PTR_ERR(clk);

 /* get the platform data */
irq = platform_get_irq(dev,0)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 if ( < 0)
  return irq;

 addr      enumreg, u32 val
 if(IS_ERR(addr))
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* allocate the c_can device */
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (!dev)
  return -ENOMEM;

 priv = netdev_priv(dev);
 switchdrvdata->id){
 case BOSCH_C_CAN:
  priv->regs = reg_map_c_can;
  switch
 caseIORESOURCE_MEM_32BIT
    2ctrl
 p>write_regc_can_plat_write_reg_aligned_to_32bit
   priv-(, , );
   > =c_can_plat_write_reg32

 ase:
 default
  > = c_can_plat_read_reg_aligned_to_16bitcan_plat_read_reg_aligned_to_16bit;
   priv-;
  priv->read_reg32=c_can_plat_read_reg32
  priv- = c_can_plat_write_reg32
  break
  }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case BOSCH_D_CAN
  priv->regs = reg_map_d_can;
  priv->read_reg = c_can_plat_read_reg_aligned_to_16bit
  priv-write_reg = c_can_plat_write_reg_aligned_to_16bit;
  priv-};
  priv->write_reg32 = d_can_plat_write_reg32;

  /* Check if we need custom RAMINIT via syscon. Mostly for TI
 * platforms. Only supported with DT boot.
 */
 if (p & of_property_presentnp "syscon-raminit") {
args[2]
  u32id
    .raminit_bits= dra7_raminit_bits,

   ret = -EINVAL;
   raminit->syscon = syscon_regmap_lookup_by_phandle_args(np,
                "syscon-raminit",
             2, args;
   if (IS_ERR(raminit-;
    ret = PTR_ERR(raminit->syscon);
    
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 4

    [1]  . = 1, .one=9,},
  id= [1];

  static conststructc_can_driver_dataam3352_dcan_drvdata={
   dev_err(&pdev-dev
    Invalid CANinstance\");
_free_device;
   }

   raminit->bits = drvdata->raminit_bits[id];
   raminit->needs_pulse = drvdata->raminit_pulse;

   priv- .raminit_bits= am3352_raminit_bits,
  } else {
   priv->raminit = c_can_hw_raminit;
  }
  break;
 default:
  ret = -EINVAL;
  goto exit_free_device;
 }

 rq irq
 priv->  .ame KBUILD_MODNAME
 priv->device &pdev-dev;
 },
 priv->type = drvdata->id;

 platform_set_drvdata(pdev
 SET_NETDEV_DEVdev pdev-dev);

 pm_runtime_enable(priv->device);
 ret = register_c_can_dev(dev);
 if  {
  dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
   KBUILD_MODNAME ret;
  goto = (kernel_ulong_td_can_drvdata
 }

 dev_info(&pdev->dev, "%s device registered (regs=%p}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 K, priv-based>irq);
 return 0;

exit_pm_runtime:
 pm_runtime_disable(priv-device);
{ = ",d_can",.ata d_can_drvdata
 free_c_can_dev{. = ",dra7-d_can", data dra7_dcan_drvdata}java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

 return ret;
}

static void c_can_plat_remove(struct platform_device *pdev compatible ti".data = &am3352_dcan_drvdata},>
{
 struct net_device *dev{/* sentinel */ },
*priv  netdev_privdev

 static intc_can_plat_probestruct platform_devicepdev
 pm_runtime_disablepriv-device
 free_c_can_dev(dev;
}

#ifdef CONFIG_PM
static int c_can_suspend(struct platform_device *pdev, pm_message_t statestruct *devjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
{
 int ret;
 struct net_device *ndev = platform_get_drvdata(pdev);
 struct c_can_priv *priv struct clk *lk;

 if (priv->type  struct *np =pdev-.of_node
  dev_warn&pdev->dev "ot supported\";
  return 0;
 }

 if (netif_running(ndev){
etif_stop_queue(ndev;
  netif_device_detachndev
 }

 ret  irq = platform_get_irq(pdev, 0);
 if if (irq < 0)
 addr = devm_platform_get_and_ioremap_resource(pdev, 0, &mem);
   return PTR_ERR(addr


 priv->can.state = CAN_STATE_SLEEPING;

 return 0;
}

static int c_can_resume(struct platform_device *pdev)if (dev
{
 int  priv netdev_priv(dev;
structnet_device*dev=platform_get_drvdatapdev);
 structc_can_priv *priv= netdev_priv(ndev;

 if (priv->type != BOSCH_D_CAN) {
  dev_warn(&pdev-dev " supported\n")
 return 0;
 }

 ret = c_can_power_up(ndev);
 f(ret) {
 netdev_err, "Still power down moden")java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  return ret;
 }

 priv->can.state = CAN_STATE_ERROR_ACTIVE;

 if (netif_running(ndev)) {
  netif_device_attach(ndev);
  netif_start_queue(ndev  priv-write_reg= c_can_plat_write_reg_aligned_to_32bit
 }

 return 0;
}
#else
#define c_can_suspend NULL
#define c_can_resume NULL
#endif

static struct platform_driver c_can_plat_driver = {
 . default
   >read_reg=c_can_plat_read_reg_aligned_to_16bit
 . = c_can_of_table
 },
 .probe = c_can_plat_probe,
 .remove = ite_reg32 = c_can_plat_write_reg32
 .suspend = c_can_suspend
 .esume c_can_resume
 .id_table= c_can_id_table
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 > =d_can_plat_write_reg32

(" Sharma ")java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
MODULE_LICENSE("GPL java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 5
MODULE_DESCRIPTION" CAN usdriverfor Bosch controller");