Patched in Tegra support.

3 files changed, 70 insertions, 65 deletions

diff --git a/drivers/net/can/mscan/mpc5xxx_can.c b/drivers/net/can/mscan/mpc5xxx_can.c
index 668850e441d..5fedc337556 100644
--- a/drivers/net/can/mscan/mpc5xxx_can.c
+++ b/drivers/net/can/mscan/mpc5xxx_can.c
@@ -43,13 +43,14 @@ struct mpc5xxx_can_data {
 };
 
 #ifdef CONFIG_PPC_MPC52xx
-static struct of_device_id mpc52xx_cdm_ids[] = {
+static struct of_device_id __devinitdata mpc52xx_cdm_ids[] = {
         { .compatible = "fsl,mpc5200-cdm", },
         {}
 };
 
-static u32 mpc52xx_can_get_clock(struct platform_device *ofdev,
-                                 const char *clock_name, int *mscan_clksrc)
+static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev,
+                                           const char *clock_name,
+                                           int *mscan_clksrc)
 {
         unsigned int pvr;
         struct mpc52xx_cdm  __iomem *cdm;
@@ -100,8 +101,9 @@ static u32 mpc52xx_can_get_clock(struct platform_device *ofdev,
         return freq;
 }
 #else /* !CONFIG_PPC_MPC52xx */
-static u32 mpc52xx_can_get_clock(struct platform_device *ofdev,
-                                 const char *clock_name, int *mscan_clksrc)
+static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev,
+                                           const char *clock_name,
+                                           int *mscan_clksrc)
 {
         return 0;
 }
@@ -122,13 +124,14 @@ struct mpc512x_clockctl {
         u32 mccr[4];            /* MSCAN Clk Ctrl Reg 1-3 */
 };
 
-static struct of_device_id mpc512x_clock_ids[] = {
+static struct of_device_id __devinitdata mpc512x_clock_ids[] = {
         { .compatible = "fsl,mpc5121-clock", },
         {}
 };
 
-static u32 mpc512x_can_get_clock(struct platform_device *ofdev,
-                                 const char *clock_name, int *mscan_clksrc)
+static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev,
+                                           const char *clock_name,
+                                           int *mscan_clksrc)
 {
         struct mpc512x_clockctl __iomem *clockctl;
         struct device_node *np_clock;
@@ -178,7 +181,7 @@ static u32 mpc512x_can_get_clock(struct platform_device *ofdev,
 
                 if (!clock_name || !strcmp(clock_name, "sys")) {
                         sys_clk = clk_get(&ofdev->dev, "sys_clk");
-                        if (IS_ERR(sys_clk)) {
+                        if (!sys_clk) {
                                 dev_err(&ofdev->dev, "couldn't get sys_clk\n");
                                 goto exit_unmap;
                         }
@@ -201,7 +204,7 @@ static u32 mpc512x_can_get_clock(struct platform_device *ofdev,
 
                 if (clocksrc < 0) {
                         ref_clk = clk_get(&ofdev->dev, "ref_clk");
-                        if (IS_ERR(ref_clk)) {
+                        if (!ref_clk) {
                                 dev_err(&ofdev->dev, "couldn't get ref_clk\n");
                                 goto exit_unmap;
                         }
@@ -236,18 +239,19 @@ exit_put:
         return freq;
 }
 #else /* !CONFIG_PPC_MPC512x */
-static u32 mpc512x_can_get_clock(struct platform_device *ofdev,
-                                 const char *clock_name, int *mscan_clksrc)
+static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev,
+                                           const char *clock_name,
+                                           int *mscan_clksrc)
 {
         return 0;
 }
 #endif /* CONFIG_PPC_MPC512x */
 
-static const struct of_device_id mpc5xxx_can_table[];
-static int mpc5xxx_can_probe(struct platform_device *ofdev)
+static struct of_device_id mpc5xxx_can_table[];
+static int __devinit mpc5xxx_can_probe(struct platform_device *ofdev)
 {
         const struct of_device_id *match;
-        const struct mpc5xxx_can_data *data;
+        struct mpc5xxx_can_data *data;
         struct device_node *np = ofdev->dev.of_node;
         struct net_device *dev;
         struct mscan_priv *priv;
@@ -319,7 +323,7 @@ exit_unmap_mem:
         return err;
 }
 
-static int mpc5xxx_can_remove(struct platform_device *ofdev)
+static int __devexit mpc5xxx_can_remove(struct platform_device *ofdev)
 {
         struct net_device *dev = dev_get_drvdata(&ofdev->dev);
         struct mscan_priv *priv = netdev_priv(dev);
@@ -376,23 +380,22 @@ static int mpc5xxx_can_resume(struct platform_device *ofdev)
 }
 #endif
 
-static const struct mpc5xxx_can_data mpc5200_can_data = {
+static struct mpc5xxx_can_data __devinitdata mpc5200_can_data = {
         .type = MSCAN_TYPE_MPC5200,
         .get_clock = mpc52xx_can_get_clock,
 };
 
-static const struct mpc5xxx_can_data mpc5121_can_data = {
+static struct mpc5xxx_can_data __devinitdata mpc5121_can_data = {
         .type = MSCAN_TYPE_MPC5121,
         .get_clock = mpc512x_can_get_clock,
 };
 
-static const struct of_device_id mpc5xxx_can_table[] = {
+static struct of_device_id __devinitdata mpc5xxx_can_table[] = {
         { .compatible = "fsl,mpc5200-mscan", .data = &mpc5200_can_data, },
         /* Note that only MPC5121 Rev. 2 (and later) is supported */
         { .compatible = "fsl,mpc5121-mscan", .data = &mpc5121_can_data, },
         {},
 };
-MODULE_DEVICE_TABLE(of, mpc5xxx_can_table);
 
 static struct platform_driver mpc5xxx_can_driver = {
         .driver = {
@@ -401,14 +404,24 @@ static struct platform_driver mpc5xxx_can_driver = {
                 .of_match_table = mpc5xxx_can_table,
         },
         .probe = mpc5xxx_can_probe,
-        .remove = mpc5xxx_can_remove,
+        .remove = __devexit_p(mpc5xxx_can_remove),
 #ifdef CONFIG_PM
         .suspend = mpc5xxx_can_suspend,
         .resume = mpc5xxx_can_resume,
 #endif
 };
 
-module_platform_driver(mpc5xxx_can_driver);
+static int __init mpc5xxx_can_init(void)
+{
+        return platform_driver_register(&mpc5xxx_can_driver);
+}
+module_init(mpc5xxx_can_init);
+
+static void __exit mpc5xxx_can_exit(void)
+{
+        platform_driver_unregister(&mpc5xxx_can_driver);
+};
+module_exit(mpc5xxx_can_exit);
 
 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
 MODULE_DESCRIPTION("Freescale MPC5xxx CAN driver");
diff --git a/drivers/net/can/mscan/mscan.c b/drivers/net/can/mscan/mscan.c
index e6b40954e20..4cc6f44c2ba 100644
--- a/drivers/net/can/mscan/mscan.c
+++ b/drivers/net/can/mscan/mscan.c
@@ -34,7 +34,7 @@
 
 #include "mscan.h"
 
-static const struct can_bittiming_const mscan_bittiming_const = {
+static struct can_bittiming_const mscan_bittiming_const = {
         .name = "mscan",
         .tseg1_min = 4,
         .tseg1_max = 16,
@@ -62,7 +62,7 @@ static enum can_state state_map[] = {
 static int mscan_set_mode(struct net_device *dev, u8 mode)
 {
         struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
         int ret = 0;
         int i;
         u8 canctl1;
@@ -95,9 +95,9 @@ static int mscan_set_mode(struct net_device *dev, u8 mode)
                          * any, at once.
                          */
                         if (i >= MSCAN_SET_MODE_RETRIES)
-                                netdev_dbg(dev,
-                                           "device failed to enter sleep mode. "
-                                           "We proceed anyhow.\n");
+                                dev_dbg(dev->dev.parent,
+                                        "device failed to enter sleep mode. "
+                                        "We proceed anyhow.\n");
                         else
                                 priv->can.state = CAN_STATE_SLEEPING;
                 }
@@ -138,7 +138,7 @@ static int mscan_set_mode(struct net_device *dev, u8 mode)
 static int mscan_start(struct net_device *dev)
 {
         struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
         u8 canrflg;
         int err;
 
@@ -178,7 +178,7 @@ static int mscan_restart(struct net_device *dev)
         struct mscan_priv *priv = netdev_priv(dev);
 
         if (priv->type == MSCAN_TYPE_MPC5121) {
-                struct mscan_regs __iomem *regs = priv->reg_base;
+                struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
 
                 priv->can.state = CAN_STATE_ERROR_ACTIVE;
                 WARN(!(in_8(&regs->canmisc) & MSCAN_BOHOLD),
@@ -199,7 +199,7 @@ static netdev_tx_t mscan_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         struct can_frame *frame = (struct can_frame *)skb->data;
         struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
         int i, rtr, buf_id;
         u32 can_id;
 
@@ -213,7 +213,7 @@ static netdev_tx_t mscan_start_xmit(struct sk_buff *skb, struct net_device *dev)
         switch (hweight8(i)) {
         case 0:
                 netif_stop_queue(dev);
-                netdev_err(dev, "Tx Ring full when queue awake!\n");
+                dev_err(dev->dev.parent, "Tx Ring full when queue awake!\n");
                 return NETDEV_TX_BUSY;
         case 1:
                 /*
@@ -307,7 +307,7 @@ static enum can_state check_set_state(struct net_device *dev, u8 canrflg)
 static void mscan_get_rx_frame(struct net_device *dev, struct can_frame *frame)
 {
         struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
         u32 can_id;
         int i;
 
@@ -348,11 +348,11 @@ static void mscan_get_err_frame(struct net_device *dev, struct can_frame *frame,
                                 u8 canrflg)
 {
         struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
         struct net_device_stats *stats = &dev->stats;
         enum can_state old_state;
 
-        netdev_dbg(dev, "error interrupt (canrflg=%#x)\n", canrflg);
+        dev_dbg(dev->dev.parent, "error interrupt (canrflg=%#x)\n", canrflg);
         frame->can_id = CAN_ERR_FLAG;
 
         if (canrflg & MSCAN_OVRIF) {
@@ -411,7 +411,7 @@ static int mscan_rx_poll(struct napi_struct *napi, int quota)
 {
         struct mscan_priv *priv = container_of(napi, struct mscan_priv, napi);
         struct net_device *dev = napi->dev;
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
         struct net_device_stats *stats = &dev->stats;
         int npackets = 0;
         int ret = 1;
@@ -427,7 +427,7 @@ static int mscan_rx_poll(struct napi_struct *napi, int quota)
                 skb = alloc_can_skb(dev, &frame);
                 if (!skb) {
                         if (printk_ratelimit())
-                                netdev_notice(dev, "packet dropped\n");
+                                dev_notice(dev->dev.parent, "packet dropped\n");
                         stats->rx_dropped++;
                         out_8(&regs->canrflg, canrflg);
                         continue;
@@ -458,7 +458,7 @@ static irqreturn_t mscan_isr(int irq, void *dev_id)
 {
         struct net_device *dev = (struct net_device *)dev_id;
         struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
         struct net_device_stats *stats = &dev->stats;
         u8 cantier, cantflg, canrflg;
         irqreturn_t ret = IRQ_NONE;
@@ -517,8 +517,12 @@ static irqreturn_t mscan_isr(int irq, void *dev_id)
 
 static int mscan_do_set_mode(struct net_device *dev, enum can_mode mode)
 {
+        struct mscan_priv *priv = netdev_priv(dev);
         int ret = 0;
 
+        if (!priv->open_time)
+                return -EINVAL;
+
         switch (mode) {
         case CAN_MODE_START:
                 ret = mscan_restart(dev);
@@ -538,7 +542,7 @@ static int mscan_do_set_mode(struct net_device *dev, enum can_mode mode)
 static int mscan_do_set_bittiming(struct net_device *dev)
 {
         struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
         struct can_bittiming *bt = &priv->can.bittiming;
         u8 btr0, btr1;
 
@@ -547,7 +551,8 @@ static int mscan_do_set_bittiming(struct net_device *dev)
                 BTR1_SET_TSEG2(bt->phase_seg2) |
                 BTR1_SET_SAM(priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES));
 
-        netdev_info(dev, "setting BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1);
+        dev_info(dev->dev.parent, "setting BTR0=0x%02x BTR1=0x%02x\n",
+                btr0, btr1);
 
         out_8(&regs->canbtr0, btr0);
         out_8(&regs->canbtr1, btr1);
@@ -555,23 +560,11 @@ static int mscan_do_set_bittiming(struct net_device *dev)
         return 0;
 }
 
-static int mscan_get_berr_counter(const struct net_device *dev,
-                                  struct can_berr_counter *bec)
-{
-        struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
-
-        bec->txerr = in_8(&regs->cantxerr);
-        bec->rxerr = in_8(&regs->canrxerr);
-
-        return 0;
-}
-
 static int mscan_open(struct net_device *dev)
 {
         int ret;
         struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
 
         /* common open */
         ret = open_candev(dev);
@@ -582,14 +575,13 @@ static int mscan_open(struct net_device *dev)
 
         ret = request_irq(dev->irq, mscan_isr, 0, dev->name, dev);
         if (ret < 0) {
-                netdev_err(dev, "failed to attach interrupt\n");
+                dev_err(dev->dev.parent, "failed to attach interrupt\n");
                 goto exit_napi_disable;
         }
 
-        if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
-                setbits8(&regs->canctl1, MSCAN_LISTEN);
-        else
-                clrbits8(&regs->canctl1, MSCAN_LISTEN);
+        priv->open_time = jiffies;
+
+        clrbits8(&regs->canctl1, MSCAN_LISTEN);
 
         ret = mscan_start(dev);
         if (ret)
@@ -600,6 +592,7 @@ static int mscan_open(struct net_device *dev)
         return 0;
 
 exit_free_irq:
+        priv->open_time = 0;
         free_irq(dev->irq, dev);
 exit_napi_disable:
         napi_disable(&priv->napi);
@@ -610,7 +603,7 @@ exit_napi_disable:
 static int mscan_close(struct net_device *dev)
 {
         struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
 
         netif_stop_queue(dev);
         napi_disable(&priv->napi);
@@ -620,6 +613,7 @@ static int mscan_close(struct net_device *dev)
         mscan_set_mode(dev, MSCAN_INIT_MODE);
         close_candev(dev);
         free_irq(dev->irq, dev);
+        priv->open_time = 0;
 
         return 0;
 }
@@ -633,7 +627,7 @@ static const struct net_device_ops mscan_netdev_ops = {
 int register_mscandev(struct net_device *dev, int mscan_clksrc)
 {
         struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
         u8 ctl1;
 
         ctl1 = in_8(&regs->canctl1);
@@ -642,10 +636,8 @@ int register_mscandev(struct net_device *dev, int mscan_clksrc)
         else
                 ctl1 &= ~MSCAN_CLKSRC;
 
-        if (priv->type == MSCAN_TYPE_MPC5121) {
-                priv->can.do_get_berr_counter = mscan_get_berr_counter;
+        if (priv->type == MSCAN_TYPE_MPC5121)
                 ctl1 |= MSCAN_BORM; /* bus-off recovery upon request */
-        }
 
         ctl1 |= MSCAN_CANE;
         out_8(&regs->canctl1, ctl1);
@@ -672,7 +664,7 @@ int register_mscandev(struct net_device *dev, int mscan_clksrc)
 void unregister_mscandev(struct net_device *dev)
 {
         struct mscan_priv *priv = netdev_priv(dev);
-        struct mscan_regs __iomem *regs = priv->reg_base;
+        struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base;
         mscan_set_mode(dev, MSCAN_INIT_MODE);
         clrbits8(&regs->canctl1, MSCAN_CANE);
         unregister_candev(dev);
@@ -698,8 +690,7 @@ struct net_device *alloc_mscandev(void)
         priv->can.bittiming_const = &mscan_bittiming_const;
         priv->can.do_set_bittiming = mscan_do_set_bittiming;
         priv->can.do_set_mode = mscan_do_set_mode;
-        priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES |
-                CAN_CTRLMODE_LISTENONLY;
+        priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
 
         for (i = 0; i < TX_QUEUE_SIZE; i++) {
                 priv->tx_queue[i].id = i;
diff --git a/drivers/net/can/mscan/mscan.h b/drivers/net/can/mscan/mscan.h
index af2ed8baf0a..b43e9f5d326 100644
--- a/drivers/net/can/mscan/mscan.h
+++ b/drivers/net/can/mscan/mscan.h
@@ -281,6 +281,7 @@ struct tx_queue_entry {
 struct mscan_priv {
         struct can_priv can;    /* must be the first member */
         unsigned int type;      /* MSCAN type variants */
+        long open_time;
         unsigned long flags;
         void __iomem *reg_base; /* ioremap'ed address to registers */
         u8 shadow_statflg;