124cfbcbaSWolfram Sang /* 224cfbcbaSWolfram Sang * CAN bus driver for the Freescale MPC5xxx embedded CPU. 324cfbcbaSWolfram Sang * 424cfbcbaSWolfram Sang * Copyright (C) 2004-2005 Andrey Volkov <avolkov@varma-el.com>, 524cfbcbaSWolfram Sang * Varma Electronics Oy 624cfbcbaSWolfram Sang * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com> 724cfbcbaSWolfram Sang * Copyright (C) 2009 Wolfram Sang, Pengutronix <w.sang@pengutronix.de> 824cfbcbaSWolfram Sang * 924cfbcbaSWolfram Sang * This program is free software; you can redistribute it and/or modify 1024cfbcbaSWolfram Sang * it under the terms of the version 2 of the GNU General Public License 1124cfbcbaSWolfram Sang * as published by the Free Software Foundation 1224cfbcbaSWolfram Sang * 1324cfbcbaSWolfram Sang * This program is distributed in the hope that it will be useful, but 1424cfbcbaSWolfram Sang * WITHOUT ANY WARRANTY; without even the implied warranty of 1524cfbcbaSWolfram Sang * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1624cfbcbaSWolfram Sang * GNU General Public License for more details. 1724cfbcbaSWolfram Sang * 1824cfbcbaSWolfram Sang * You should have received a copy of the GNU General Public License 1924cfbcbaSWolfram Sang * along with this program; if not, write to the Free Software 2024cfbcbaSWolfram Sang * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 2124cfbcbaSWolfram Sang */ 2224cfbcbaSWolfram Sang 2324cfbcbaSWolfram Sang #include <linux/kernel.h> 2424cfbcbaSWolfram Sang #include <linux/module.h> 2524cfbcbaSWolfram Sang #include <linux/interrupt.h> 2624cfbcbaSWolfram Sang #include <linux/platform_device.h> 2724cfbcbaSWolfram Sang #include <linux/netdevice.h> 2824cfbcbaSWolfram Sang #include <linux/can.h> 2924cfbcbaSWolfram Sang #include <linux/can/dev.h> 3024cfbcbaSWolfram Sang #include <linux/of_platform.h> 3124cfbcbaSWolfram Sang #include <sysdev/fsl_soc.h> 32bf3af547SWolfgang Grandegger #include <linux/clk.h> 3324cfbcbaSWolfram Sang #include <linux/io.h> 3424cfbcbaSWolfram Sang #include <asm/mpc52xx.h> 3524cfbcbaSWolfram Sang 3624cfbcbaSWolfram Sang #include "mscan.h" 3724cfbcbaSWolfram Sang 3824cfbcbaSWolfram Sang #define DRV_NAME "mpc5xxx_can" 3924cfbcbaSWolfram Sang 40bf3af547SWolfgang Grandegger struct mpc5xxx_can_data { 41bf3af547SWolfgang Grandegger unsigned int type; 42bf3af547SWolfgang Grandegger u32 (*get_clock)(struct of_device *ofdev, const char *clock_name, 43bf3af547SWolfgang Grandegger int *mscan_clksrc); 44bf3af547SWolfgang Grandegger }; 45bf3af547SWolfgang Grandegger 46c5bab5e9SWolfgang Grandegger #ifdef CONFIG_PPC_MPC52xx 47bf3af547SWolfgang Grandegger static struct of_device_id __devinitdata mpc52xx_cdm_ids[] = { 4824cfbcbaSWolfram Sang { .compatible = "fsl,mpc5200-cdm", }, 4924cfbcbaSWolfram Sang {} 5024cfbcbaSWolfram Sang }; 5124cfbcbaSWolfram Sang 52bf3af547SWolfgang Grandegger static u32 __devinit mpc52xx_can_get_clock(struct of_device *ofdev, 53bf3af547SWolfgang Grandegger const char *clock_name, 54bf3af547SWolfgang Grandegger int *mscan_clksrc) 5524cfbcbaSWolfram Sang { 5624cfbcbaSWolfram Sang unsigned int pvr; 5724cfbcbaSWolfram Sang struct mpc52xx_cdm __iomem *cdm; 5824cfbcbaSWolfram Sang struct device_node *np_cdm; 5924cfbcbaSWolfram Sang unsigned int freq; 6024cfbcbaSWolfram Sang u32 val; 6124cfbcbaSWolfram Sang 6224cfbcbaSWolfram Sang pvr = mfspr(SPRN_PVR); 6324cfbcbaSWolfram Sang 64bf3af547SWolfgang Grandegger /* 65bf3af547SWolfgang Grandegger * Either the oscillator clock (SYS_XTAL_IN) or the IP bus clock 66bf3af547SWolfgang Grandegger * (IP_CLK) can be selected as MSCAN clock source. According to 67bf3af547SWolfgang Grandegger * the MPC5200 user's manual, the oscillator clock is the better 68bf3af547SWolfgang Grandegger * choice as it has less jitter. For this reason, it is selected 69bf3af547SWolfgang Grandegger * by default. Unfortunately, it can not be selected for the old 70bf3af547SWolfgang Grandegger * MPC5200 Rev. A chips due to a hardware bug (check errata). 71bf3af547SWolfgang Grandegger */ 72bf3af547SWolfgang Grandegger if (clock_name && strcmp(clock_name, "ip") == 0) 73bf3af547SWolfgang Grandegger *mscan_clksrc = MSCAN_CLKSRC_BUS; 74bf3af547SWolfgang Grandegger else 75bf3af547SWolfgang Grandegger *mscan_clksrc = MSCAN_CLKSRC_XTAL; 76bf3af547SWolfgang Grandegger 77bf3af547SWolfgang Grandegger freq = mpc5xxx_get_bus_frequency(ofdev->node); 7824cfbcbaSWolfram Sang if (!freq) 7924cfbcbaSWolfram Sang return 0; 8024cfbcbaSWolfram Sang 81bf3af547SWolfgang Grandegger if (*mscan_clksrc == MSCAN_CLKSRC_BUS || pvr == 0x80822011) 8224cfbcbaSWolfram Sang return freq; 8324cfbcbaSWolfram Sang 8424cfbcbaSWolfram Sang /* Determine SYS_XTAL_IN frequency from the clock domain settings */ 8524cfbcbaSWolfram Sang np_cdm = of_find_matching_node(NULL, mpc52xx_cdm_ids); 8624cfbcbaSWolfram Sang if (!np_cdm) { 87c5bab5e9SWolfgang Grandegger dev_err(&ofdev->dev, "can't get clock node!\n"); 8824cfbcbaSWolfram Sang return 0; 8924cfbcbaSWolfram Sang } 9024cfbcbaSWolfram Sang cdm = of_iomap(np_cdm, 0); 9124cfbcbaSWolfram Sang 9224cfbcbaSWolfram Sang if (in_8(&cdm->ipb_clk_sel) & 0x1) 9324cfbcbaSWolfram Sang freq *= 2; 9424cfbcbaSWolfram Sang val = in_be32(&cdm->rstcfg); 9524cfbcbaSWolfram Sang 9624cfbcbaSWolfram Sang freq *= (val & (1 << 5)) ? 8 : 4; 9724cfbcbaSWolfram Sang freq /= (val & (1 << 6)) ? 12 : 16; 9824cfbcbaSWolfram Sang 99bf3af547SWolfgang Grandegger of_node_put(np_cdm); 10024cfbcbaSWolfram Sang iounmap(cdm); 10124cfbcbaSWolfram Sang 10224cfbcbaSWolfram Sang return freq; 10324cfbcbaSWolfram Sang } 104c5bab5e9SWolfgang Grandegger #else /* !CONFIG_PPC_MPC52xx */ 105bf3af547SWolfgang Grandegger static u32 __devinit mpc52xx_can_get_clock(struct of_device *ofdev, 106bf3af547SWolfgang Grandegger const char *clock_name, 107bf3af547SWolfgang Grandegger int *mscan_clksrc) 108bf3af547SWolfgang Grandegger { 109bf3af547SWolfgang Grandegger return 0; 110bf3af547SWolfgang Grandegger } 111c5bab5e9SWolfgang Grandegger #endif /* CONFIG_PPC_MPC52xx */ 112bf3af547SWolfgang Grandegger 113bf3af547SWolfgang Grandegger #ifdef CONFIG_PPC_MPC512x 114bf3af547SWolfgang Grandegger struct mpc512x_clockctl { 115bf3af547SWolfgang Grandegger u32 spmr; /* System PLL Mode Reg */ 116bf3af547SWolfgang Grandegger u32 sccr[2]; /* System Clk Ctrl Reg 1 & 2 */ 117bf3af547SWolfgang Grandegger u32 scfr1; /* System Clk Freq Reg 1 */ 118bf3af547SWolfgang Grandegger u32 scfr2; /* System Clk Freq Reg 2 */ 119bf3af547SWolfgang Grandegger u32 reserved; 120bf3af547SWolfgang Grandegger u32 bcr; /* Bread Crumb Reg */ 121bf3af547SWolfgang Grandegger u32 pccr[12]; /* PSC Clk Ctrl Reg 0-11 */ 122bf3af547SWolfgang Grandegger u32 spccr; /* SPDIF Clk Ctrl Reg */ 123bf3af547SWolfgang Grandegger u32 cccr; /* CFM Clk Ctrl Reg */ 124bf3af547SWolfgang Grandegger u32 dccr; /* DIU Clk Cnfg Reg */ 125bf3af547SWolfgang Grandegger u32 mccr[4]; /* MSCAN Clk Ctrl Reg 1-3 */ 126bf3af547SWolfgang Grandegger }; 127bf3af547SWolfgang Grandegger 128bf3af547SWolfgang Grandegger static struct of_device_id __devinitdata mpc512x_clock_ids[] = { 129bf3af547SWolfgang Grandegger { .compatible = "fsl,mpc5121-clock", }, 130bf3af547SWolfgang Grandegger {} 131bf3af547SWolfgang Grandegger }; 132bf3af547SWolfgang Grandegger 133bf3af547SWolfgang Grandegger static u32 __devinit mpc512x_can_get_clock(struct of_device *ofdev, 134bf3af547SWolfgang Grandegger const char *clock_name, 135bf3af547SWolfgang Grandegger int *mscan_clksrc) 136bf3af547SWolfgang Grandegger { 137bf3af547SWolfgang Grandegger struct mpc512x_clockctl __iomem *clockctl; 138bf3af547SWolfgang Grandegger struct device_node *np_clock; 139bf3af547SWolfgang Grandegger struct clk *sys_clk, *ref_clk; 140bf3af547SWolfgang Grandegger int plen, clockidx, clocksrc = -1; 141bf3af547SWolfgang Grandegger u32 sys_freq, val, clockdiv = 1, freq = 0; 142bf3af547SWolfgang Grandegger const u32 *pval; 143bf3af547SWolfgang Grandegger 144bf3af547SWolfgang Grandegger np_clock = of_find_matching_node(NULL, mpc512x_clock_ids); 145bf3af547SWolfgang Grandegger if (!np_clock) { 146bf3af547SWolfgang Grandegger dev_err(&ofdev->dev, "couldn't find clock node\n"); 147bf3af547SWolfgang Grandegger return -ENODEV; 148bf3af547SWolfgang Grandegger } 149bf3af547SWolfgang Grandegger clockctl = of_iomap(np_clock, 0); 150bf3af547SWolfgang Grandegger if (!clockctl) { 151bf3af547SWolfgang Grandegger dev_err(&ofdev->dev, "couldn't map clock registers\n"); 152bf3af547SWolfgang Grandegger return 0; 153bf3af547SWolfgang Grandegger } 154bf3af547SWolfgang Grandegger 155bf3af547SWolfgang Grandegger /* Determine the MSCAN device index from the physical address */ 156bf3af547SWolfgang Grandegger pval = of_get_property(ofdev->node, "reg", &plen); 157bf3af547SWolfgang Grandegger BUG_ON(!pval || plen < sizeof(*pval)); 158bf3af547SWolfgang Grandegger clockidx = (*pval & 0x80) ? 1 : 0; 159bf3af547SWolfgang Grandegger if (*pval & 0x2000) 160bf3af547SWolfgang Grandegger clockidx += 2; 161bf3af547SWolfgang Grandegger 162bf3af547SWolfgang Grandegger /* 163bf3af547SWolfgang Grandegger * Clock source and divider selection: 3 different clock sources 164bf3af547SWolfgang Grandegger * can be selected: "ip", "ref" or "sys". For the latter two, a 165bf3af547SWolfgang Grandegger * clock divider can be defined as well. If the clock source is 166bf3af547SWolfgang Grandegger * not specified by the device tree, we first try to find an 167bf3af547SWolfgang Grandegger * optimal CAN source clock based on the system clock. If that 168bf3af547SWolfgang Grandegger * is not posslible, the reference clock will be used. 169bf3af547SWolfgang Grandegger */ 170bf3af547SWolfgang Grandegger if (clock_name && !strcmp(clock_name, "ip")) { 171bf3af547SWolfgang Grandegger *mscan_clksrc = MSCAN_CLKSRC_IPS; 172bf3af547SWolfgang Grandegger freq = mpc5xxx_get_bus_frequency(ofdev->node); 173bf3af547SWolfgang Grandegger } else { 174bf3af547SWolfgang Grandegger *mscan_clksrc = MSCAN_CLKSRC_BUS; 175bf3af547SWolfgang Grandegger 176bf3af547SWolfgang Grandegger pval = of_get_property(ofdev->node, 177bf3af547SWolfgang Grandegger "fsl,mscan-clock-divider", &plen); 178bf3af547SWolfgang Grandegger if (pval && plen == sizeof(*pval)) 179bf3af547SWolfgang Grandegger clockdiv = *pval; 180bf3af547SWolfgang Grandegger if (!clockdiv) 181bf3af547SWolfgang Grandegger clockdiv = 1; 182bf3af547SWolfgang Grandegger 183bf3af547SWolfgang Grandegger if (!clock_name || !strcmp(clock_name, "sys")) { 184bf3af547SWolfgang Grandegger sys_clk = clk_get(&ofdev->dev, "sys_clk"); 185bf3af547SWolfgang Grandegger if (!sys_clk) { 186bf3af547SWolfgang Grandegger dev_err(&ofdev->dev, "couldn't get sys_clk\n"); 187bf3af547SWolfgang Grandegger goto exit_unmap; 188bf3af547SWolfgang Grandegger } 189bf3af547SWolfgang Grandegger /* Get and round up/down sys clock rate */ 190bf3af547SWolfgang Grandegger sys_freq = 1000000 * 191bf3af547SWolfgang Grandegger ((clk_get_rate(sys_clk) + 499999) / 1000000); 192bf3af547SWolfgang Grandegger 193bf3af547SWolfgang Grandegger if (!clock_name) { 194bf3af547SWolfgang Grandegger /* A multiple of 16 MHz would be optimal */ 195bf3af547SWolfgang Grandegger if ((sys_freq % 16000000) == 0) { 196bf3af547SWolfgang Grandegger clocksrc = 0; 197bf3af547SWolfgang Grandegger clockdiv = sys_freq / 16000000; 198bf3af547SWolfgang Grandegger freq = sys_freq / clockdiv; 199bf3af547SWolfgang Grandegger } 200bf3af547SWolfgang Grandegger } else { 201bf3af547SWolfgang Grandegger clocksrc = 0; 202bf3af547SWolfgang Grandegger freq = sys_freq / clockdiv; 203bf3af547SWolfgang Grandegger } 204bf3af547SWolfgang Grandegger } 205bf3af547SWolfgang Grandegger 206bf3af547SWolfgang Grandegger if (clocksrc < 0) { 207bf3af547SWolfgang Grandegger ref_clk = clk_get(&ofdev->dev, "ref_clk"); 208bf3af547SWolfgang Grandegger if (!ref_clk) { 209bf3af547SWolfgang Grandegger dev_err(&ofdev->dev, "couldn't get ref_clk\n"); 210bf3af547SWolfgang Grandegger goto exit_unmap; 211bf3af547SWolfgang Grandegger } 212bf3af547SWolfgang Grandegger clocksrc = 1; 213bf3af547SWolfgang Grandegger freq = clk_get_rate(ref_clk) / clockdiv; 214bf3af547SWolfgang Grandegger } 215bf3af547SWolfgang Grandegger } 216bf3af547SWolfgang Grandegger 217bf3af547SWolfgang Grandegger /* Disable clock */ 218bf3af547SWolfgang Grandegger out_be32(&clockctl->mccr[clockidx], 0x0); 219bf3af547SWolfgang Grandegger if (clocksrc >= 0) { 220bf3af547SWolfgang Grandegger /* Set source and divider */ 221bf3af547SWolfgang Grandegger val = (clocksrc << 14) | ((clockdiv - 1) << 17); 222bf3af547SWolfgang Grandegger out_be32(&clockctl->mccr[clockidx], val); 223bf3af547SWolfgang Grandegger /* Enable clock */ 224bf3af547SWolfgang Grandegger out_be32(&clockctl->mccr[clockidx], val | 0x10000); 225bf3af547SWolfgang Grandegger } 226bf3af547SWolfgang Grandegger 227bf3af547SWolfgang Grandegger /* Enable MSCAN clock domain */ 228bf3af547SWolfgang Grandegger val = in_be32(&clockctl->sccr[1]); 229bf3af547SWolfgang Grandegger if (!(val & (1 << 25))) 230bf3af547SWolfgang Grandegger out_be32(&clockctl->sccr[1], val | (1 << 25)); 231bf3af547SWolfgang Grandegger 232bf3af547SWolfgang Grandegger dev_dbg(&ofdev->dev, "using '%s' with frequency divider %d\n", 233bf3af547SWolfgang Grandegger *mscan_clksrc == MSCAN_CLKSRC_IPS ? "ips_clk" : 234bf3af547SWolfgang Grandegger clocksrc == 1 ? "ref_clk" : "sys_clk", clockdiv); 235bf3af547SWolfgang Grandegger 236bf3af547SWolfgang Grandegger exit_unmap: 237bf3af547SWolfgang Grandegger of_node_put(np_clock); 238bf3af547SWolfgang Grandegger iounmap(clockctl); 239bf3af547SWolfgang Grandegger 240bf3af547SWolfgang Grandegger return freq; 241bf3af547SWolfgang Grandegger } 242bf3af547SWolfgang Grandegger #else /* !CONFIG_PPC_MPC512x */ 243bf3af547SWolfgang Grandegger static u32 __devinit mpc512x_can_get_clock(struct of_device *ofdev, 244bf3af547SWolfgang Grandegger const char *clock_name, 245bf3af547SWolfgang Grandegger int *mscan_clksrc) 246bf3af547SWolfgang Grandegger { 247bf3af547SWolfgang Grandegger return 0; 248bf3af547SWolfgang Grandegger } 249bf3af547SWolfgang Grandegger #endif /* CONFIG_PPC_MPC512x */ 25024cfbcbaSWolfram Sang 25124cfbcbaSWolfram Sang static int __devinit mpc5xxx_can_probe(struct of_device *ofdev, 25224cfbcbaSWolfram Sang const struct of_device_id *id) 25324cfbcbaSWolfram Sang { 254bf3af547SWolfgang Grandegger struct mpc5xxx_can_data *data = (struct mpc5xxx_can_data *)id->data; 25524cfbcbaSWolfram Sang struct device_node *np = ofdev->node; 25624cfbcbaSWolfram Sang struct net_device *dev; 25724cfbcbaSWolfram Sang struct mscan_priv *priv; 25824cfbcbaSWolfram Sang void __iomem *base; 259bf3af547SWolfgang Grandegger const char *clock_name = NULL; 260bf3af547SWolfgang Grandegger int irq, mscan_clksrc = 0; 261bf3af547SWolfgang Grandegger int err = -ENOMEM; 26224cfbcbaSWolfram Sang 263bf3af547SWolfgang Grandegger base = of_iomap(np, 0); 26424cfbcbaSWolfram Sang if (!base) { 26524cfbcbaSWolfram Sang dev_err(&ofdev->dev, "couldn't ioremap\n"); 266bf3af547SWolfgang Grandegger return err; 26724cfbcbaSWolfram Sang } 26824cfbcbaSWolfram Sang 26924cfbcbaSWolfram Sang irq = irq_of_parse_and_map(np, 0); 27024cfbcbaSWolfram Sang if (!irq) { 27124cfbcbaSWolfram Sang dev_err(&ofdev->dev, "no irq found\n"); 27224cfbcbaSWolfram Sang err = -ENODEV; 27324cfbcbaSWolfram Sang goto exit_unmap_mem; 27424cfbcbaSWolfram Sang } 27524cfbcbaSWolfram Sang 27624cfbcbaSWolfram Sang dev = alloc_mscandev(); 277bf3af547SWolfgang Grandegger if (!dev) 27824cfbcbaSWolfram Sang goto exit_dispose_irq; 27924cfbcbaSWolfram Sang 28024cfbcbaSWolfram Sang priv = netdev_priv(dev); 28124cfbcbaSWolfram Sang priv->reg_base = base; 28224cfbcbaSWolfram Sang dev->irq = irq; 28324cfbcbaSWolfram Sang 284bf3af547SWolfgang Grandegger clock_name = of_get_property(np, "fsl,mscan-clock-source", NULL); 285bf3af547SWolfgang Grandegger 286bf3af547SWolfgang Grandegger BUG_ON(!data); 287bf3af547SWolfgang Grandegger priv->type = data->type; 288bf3af547SWolfgang Grandegger priv->can.clock.freq = data->get_clock(ofdev, clock_name, 289bf3af547SWolfgang Grandegger &mscan_clksrc); 29024cfbcbaSWolfram Sang if (!priv->can.clock.freq) { 291bf3af547SWolfgang Grandegger dev_err(&ofdev->dev, "couldn't get MSCAN clock properties\n"); 29224cfbcbaSWolfram Sang goto exit_free_mscan; 29324cfbcbaSWolfram Sang } 29424cfbcbaSWolfram Sang 29524cfbcbaSWolfram Sang SET_NETDEV_DEV(dev, &ofdev->dev); 29624cfbcbaSWolfram Sang 297bf3af547SWolfgang Grandegger err = register_mscandev(dev, mscan_clksrc); 29824cfbcbaSWolfram Sang if (err) { 29924cfbcbaSWolfram Sang dev_err(&ofdev->dev, "registering %s failed (err=%d)\n", 30024cfbcbaSWolfram Sang DRV_NAME, err); 30124cfbcbaSWolfram Sang goto exit_free_mscan; 30224cfbcbaSWolfram Sang } 30324cfbcbaSWolfram Sang 30424cfbcbaSWolfram Sang dev_set_drvdata(&ofdev->dev, dev); 30524cfbcbaSWolfram Sang 30624cfbcbaSWolfram Sang dev_info(&ofdev->dev, "MSCAN at 0x%p, irq %d, clock %d Hz\n", 30724cfbcbaSWolfram Sang priv->reg_base, dev->irq, priv->can.clock.freq); 30824cfbcbaSWolfram Sang 30924cfbcbaSWolfram Sang return 0; 31024cfbcbaSWolfram Sang 31124cfbcbaSWolfram Sang exit_free_mscan: 31224cfbcbaSWolfram Sang free_candev(dev); 31324cfbcbaSWolfram Sang exit_dispose_irq: 31424cfbcbaSWolfram Sang irq_dispose_mapping(irq); 31524cfbcbaSWolfram Sang exit_unmap_mem: 31624cfbcbaSWolfram Sang iounmap(base); 317bf3af547SWolfgang Grandegger 31824cfbcbaSWolfram Sang return err; 31924cfbcbaSWolfram Sang } 32024cfbcbaSWolfram Sang 32124cfbcbaSWolfram Sang static int __devexit mpc5xxx_can_remove(struct of_device *ofdev) 32224cfbcbaSWolfram Sang { 32324cfbcbaSWolfram Sang struct net_device *dev = dev_get_drvdata(&ofdev->dev); 32424cfbcbaSWolfram Sang struct mscan_priv *priv = netdev_priv(dev); 32524cfbcbaSWolfram Sang 32624cfbcbaSWolfram Sang dev_set_drvdata(&ofdev->dev, NULL); 32724cfbcbaSWolfram Sang 32824cfbcbaSWolfram Sang unregister_mscandev(dev); 32924cfbcbaSWolfram Sang iounmap(priv->reg_base); 33024cfbcbaSWolfram Sang irq_dispose_mapping(dev->irq); 33124cfbcbaSWolfram Sang free_candev(dev); 33224cfbcbaSWolfram Sang 33324cfbcbaSWolfram Sang return 0; 33424cfbcbaSWolfram Sang } 33524cfbcbaSWolfram Sang 33624cfbcbaSWolfram Sang #ifdef CONFIG_PM 33724cfbcbaSWolfram Sang static struct mscan_regs saved_regs; 33824cfbcbaSWolfram Sang static int mpc5xxx_can_suspend(struct of_device *ofdev, pm_message_t state) 33924cfbcbaSWolfram Sang { 34024cfbcbaSWolfram Sang struct net_device *dev = dev_get_drvdata(&ofdev->dev); 34124cfbcbaSWolfram Sang struct mscan_priv *priv = netdev_priv(dev); 34224cfbcbaSWolfram Sang struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base; 34324cfbcbaSWolfram Sang 34424cfbcbaSWolfram Sang _memcpy_fromio(&saved_regs, regs, sizeof(*regs)); 34524cfbcbaSWolfram Sang 34624cfbcbaSWolfram Sang return 0; 34724cfbcbaSWolfram Sang } 34824cfbcbaSWolfram Sang 34924cfbcbaSWolfram Sang static int mpc5xxx_can_resume(struct of_device *ofdev) 35024cfbcbaSWolfram Sang { 35124cfbcbaSWolfram Sang struct net_device *dev = dev_get_drvdata(&ofdev->dev); 35224cfbcbaSWolfram Sang struct mscan_priv *priv = netdev_priv(dev); 35324cfbcbaSWolfram Sang struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base; 35424cfbcbaSWolfram Sang 35524cfbcbaSWolfram Sang regs->canctl0 |= MSCAN_INITRQ; 35624cfbcbaSWolfram Sang while (!(regs->canctl1 & MSCAN_INITAK)) 35724cfbcbaSWolfram Sang udelay(10); 35824cfbcbaSWolfram Sang 35924cfbcbaSWolfram Sang regs->canctl1 = saved_regs.canctl1; 36024cfbcbaSWolfram Sang regs->canbtr0 = saved_regs.canbtr0; 36124cfbcbaSWolfram Sang regs->canbtr1 = saved_regs.canbtr1; 36224cfbcbaSWolfram Sang regs->canidac = saved_regs.canidac; 36324cfbcbaSWolfram Sang 36424cfbcbaSWolfram Sang /* restore masks, buffers etc. */ 36524cfbcbaSWolfram Sang _memcpy_toio(®s->canidar1_0, (void *)&saved_regs.canidar1_0, 36624cfbcbaSWolfram Sang sizeof(*regs) - offsetof(struct mscan_regs, canidar1_0)); 36724cfbcbaSWolfram Sang 36824cfbcbaSWolfram Sang regs->canctl0 &= ~MSCAN_INITRQ; 36924cfbcbaSWolfram Sang regs->cantbsel = saved_regs.cantbsel; 37024cfbcbaSWolfram Sang regs->canrier = saved_regs.canrier; 37124cfbcbaSWolfram Sang regs->cantier = saved_regs.cantier; 37224cfbcbaSWolfram Sang regs->canctl0 = saved_regs.canctl0; 37324cfbcbaSWolfram Sang 37424cfbcbaSWolfram Sang return 0; 37524cfbcbaSWolfram Sang } 37624cfbcbaSWolfram Sang #endif 37724cfbcbaSWolfram Sang 378bf3af547SWolfgang Grandegger static struct mpc5xxx_can_data __devinitdata mpc5200_can_data = { 379bf3af547SWolfgang Grandegger .type = MSCAN_TYPE_MPC5200, 380bf3af547SWolfgang Grandegger .get_clock = mpc52xx_can_get_clock, 381bf3af547SWolfgang Grandegger }; 382bf3af547SWolfgang Grandegger 383bf3af547SWolfgang Grandegger static struct mpc5xxx_can_data __devinitdata mpc5121_can_data = { 384bf3af547SWolfgang Grandegger .type = MSCAN_TYPE_MPC5121, 385bf3af547SWolfgang Grandegger .get_clock = mpc512x_can_get_clock, 386bf3af547SWolfgang Grandegger }; 387bf3af547SWolfgang Grandegger 38824cfbcbaSWolfram Sang static struct of_device_id __devinitdata mpc5xxx_can_table[] = { 389bf3af547SWolfgang Grandegger { .compatible = "fsl,mpc5200-mscan", .data = &mpc5200_can_data, }, 390bf3af547SWolfgang Grandegger /* Note that only MPC5121 Rev. 2 (and later) is supported */ 391bf3af547SWolfgang Grandegger { .compatible = "fsl,mpc5121-mscan", .data = &mpc5121_can_data, }, 39224cfbcbaSWolfram Sang {}, 39324cfbcbaSWolfram Sang }; 39424cfbcbaSWolfram Sang 39524cfbcbaSWolfram Sang static struct of_platform_driver mpc5xxx_can_driver = { 3964018294bSGrant Likely .driver = { 39724cfbcbaSWolfram Sang .name = "mpc5xxx_can", 3984018294bSGrant Likely .owner = THIS_MODULE, 3994018294bSGrant Likely .of_match_table = mpc5xxx_can_table, 4004018294bSGrant Likely }, 40124cfbcbaSWolfram Sang .probe = mpc5xxx_can_probe, 40224cfbcbaSWolfram Sang .remove = __devexit_p(mpc5xxx_can_remove), 40324cfbcbaSWolfram Sang #ifdef CONFIG_PM 40424cfbcbaSWolfram Sang .suspend = mpc5xxx_can_suspend, 40524cfbcbaSWolfram Sang .resume = mpc5xxx_can_resume, 40624cfbcbaSWolfram Sang #endif 40724cfbcbaSWolfram Sang }; 40824cfbcbaSWolfram Sang 40924cfbcbaSWolfram Sang static int __init mpc5xxx_can_init(void) 41024cfbcbaSWolfram Sang { 41124cfbcbaSWolfram Sang return of_register_platform_driver(&mpc5xxx_can_driver); 41224cfbcbaSWolfram Sang } 41324cfbcbaSWolfram Sang module_init(mpc5xxx_can_init); 41424cfbcbaSWolfram Sang 41524cfbcbaSWolfram Sang static void __exit mpc5xxx_can_exit(void) 41624cfbcbaSWolfram Sang { 41724cfbcbaSWolfram Sang return of_unregister_platform_driver(&mpc5xxx_can_driver); 41824cfbcbaSWolfram Sang }; 41924cfbcbaSWolfram Sang module_exit(mpc5xxx_can_exit); 42024cfbcbaSWolfram Sang 42124cfbcbaSWolfram Sang MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>"); 422bf3af547SWolfgang Grandegger MODULE_DESCRIPTION("Freescale MPC5xxx CAN driver"); 42324cfbcbaSWolfram Sang MODULE_LICENSE("GPL v2"); 424