arch/powerpc/platforms/8xx/mpc885ads_setup.c

   1 /*arch/powerpc/platforms/8xx/mpc885ads_setup.c
   2  *
   3  * Platform setup for the Freescale mpc885ads board
   4  *
   5  * Vitaly Bordug <vbordug@ru.mvista.com>
   6  *
   7  * Copyright 2005 MontaVista Software Inc.
   8  *
   9  * This file is licensed under the terms of the GNU General Public License
  10  * version 2. This program is licensed "as is" without any warranty of any
  11  * kind, whether express or implied.
  12  */
  13
  14 #include <linux/init.h>
  15 #include <linux/module.h>
  16 #include <linux/param.h>
  17 #include <linux/string.h>
  18 #include <linux/ioport.h>
  19 #include <linux/device.h>
  20 #include <linux/delay.h>
  21 #include <linux/root_dev.h>
  22
  23 #include <linux/fs_enet_pd.h>
  24 #include <linux/fs_uart_pd.h>
  25 #include <linux/fsl_devices.h>
  26 #include <linux/mii.h>
  27
  28 #include <asm/delay.h>
  29 #include <asm/io.h>
  30 #include <asm/machdep.h>
  31 #include <asm/page.h>
  32 #include <asm/processor.h>
  33 #include <asm/system.h>
  34 #include <asm/time.h>
  35 #include <asm/mpc8xx.h>
  36 #include <asm/8xx_immap.h>
  37 #include <asm/commproc.h>
  38 #include <asm/fs_pd.h>
  39 #include <asm/prom.h>
  40
  41 #include <sysdev/commproc.h>
  42
  43 static void init_smc1_uart_ioports(struct fs_uart_platform_info *fpi);
  44 static void init_smc2_uart_ioports(struct fs_uart_platform_info *fpi);
  45 static void init_scc3_ioports(struct fs_platform_info *ptr);
  46
  47 #ifdef CONFIG_PCMCIA_M8XX
  48 static void pcmcia_hw_setup(int slot, int enable)
  49 {
  50         unsigned *bcsr_io;
  51
  52         bcsr_io = ioremap(BCSR1, sizeof(unsigned long));
  53         if (enable)
  54                 clrbits32(bcsr_io, BCSR1_PCCEN);
  55         else
  56                 setbits32(bcsr_io, BCSR1_PCCEN);
  57
  58         iounmap(bcsr_io);
  59 }
  60
  61 static int pcmcia_set_voltage(int slot, int vcc, int vpp)
  62 {
  63         u32 reg = 0;
  64         unsigned *bcsr_io;
  65
  66         bcsr_io = ioremap(BCSR1, sizeof(unsigned long));
  67
  68         switch (vcc) {
  69         case 0:
  70                 break;
  71         case 33:
  72                 reg |= BCSR1_PCCVCC0;
  73                 break;
  74         case 50:
  75                 reg |= BCSR1_PCCVCC1;
  76                 break;
  77         default:
  78                 return 1;
  79         }
  80
  81         switch (vpp) {
  82         case 0:
  83                 break;
  84         case 33:
  85         case 50:
  86                 if (vcc == vpp)
  87                         reg |= BCSR1_PCCVPP1;
  88                 else
  89                         return 1;
  90                 break;
  91         case 120:
  92                 if ((vcc == 33) || (vcc == 50))
  93                         reg |= BCSR1_PCCVPP0;
  94                 else
  95                         return 1;
  96         default:
  97                 return 1;
  98         }
  99
 100         /* first, turn off all power */
 101         clrbits32(bcsr_io, 0x00610000);
 102
 103         /* enable new powersettings */
 104         setbits32(bcsr_io, reg);
 105
 106         iounmap(bcsr_io);
 107         return 0;
 108 }
 109 #endif
 110
 111 void __init mpc885ads_board_setup(void)
 112 {
 113         cpm8xx_t *cp;
 114         unsigned int *bcsr_io;
 115         u8 tmpval8;
 116
 117 #ifdef CONFIG_FS_ENET
 118         iop8xx_t *io_port;
 119 #endif
 120
 121         bcsr_io = ioremap(BCSR1, sizeof(unsigned long));
 122         cp = (cpm8xx_t *) immr_map(im_cpm);
 123
 124         if (bcsr_io == NULL) {
 125                 printk(KERN_CRIT "Could not remap BCSR\n");
 126                 return;
 127         }
 128 #ifdef CONFIG_SERIAL_CPM_SMC1
 129         clrbits32(bcsr_io, BCSR1_RS232EN_1);
 130         clrbits32(&cp->cp_simode, 0xe0000000 >> 17);    /* brg1 */
 131         tmpval8 = in_8(&(cp->cp_smc[0].smc_smcm)) | (SMCM_RX | SMCM_TX);
 132         out_8(&(cp->cp_smc[0].smc_smcm), tmpval8);
 133         clrbits16(&cp->cp_smc[0].smc_smcmr, SMCMR_REN | SMCMR_TEN);     /* brg1 */
 134 #else
 135         setbits32(bcsr_io, BCSR1_RS232EN_1);
 136         out_be16(&cp->cp_smc[0].smc_smcmr, 0);
 137         out_8(&cp->cp_smc[0].smc_smce, 0);
 138 #endif
 139
 140 #ifdef CONFIG_SERIAL_CPM_SMC2
 141         clrbits32(bcsr_io, BCSR1_RS232EN_2);
 142         clrbits32(&cp->cp_simode, 0xe0000000 >> 1);
 143         setbits32(&cp->cp_simode, 0x20000000 >> 1);     /* brg2 */
 144         tmpval8 = in_8(&(cp->cp_smc[1].smc_smcm)) | (SMCM_RX | SMCM_TX);
 145         out_8(&(cp->cp_smc[1].smc_smcm), tmpval8);
 146         clrbits16(&cp->cp_smc[1].smc_smcmr, SMCMR_REN | SMCMR_TEN);
 147
 148         init_smc2_uart_ioports(0);
 149 #else
 150         setbits32(bcsr_io, BCSR1_RS232EN_2);
 151         out_be16(&cp->cp_smc[1].smc_smcmr, 0);
 152         out_8(&cp->cp_smc[1].smc_smce, 0);
 153 #endif
 154         immr_unmap(cp);
 155         iounmap(bcsr_io);
 156
 157 #ifdef CONFIG_FS_ENET
 158         /* use MDC for MII (common) */
 159         io_port = (iop8xx_t *) immr_map(im_ioport);
 160         setbits16(&io_port->iop_pdpar, 0x0080);
 161         clrbits16(&io_port->iop_pddir, 0x0080);
 162
 163         bcsr_io = ioremap(BCSR5, sizeof(unsigned long));
 164         clrbits32(bcsr_io, BCSR5_MII1_EN);
 165         clrbits32(bcsr_io, BCSR5_MII1_RST);
 166 #ifndef CONFIG_FC_ENET_HAS_SCC
 167         clrbits32(bcsr_io, BCSR5_MII2_EN);
 168         clrbits32(bcsr_io, BCSR5_MII2_RST);
 169
 170 #endif
 171         iounmap(bcsr_io);
 172         immr_unmap(io_port);
 173
 174 #endif
 175
 176 #ifdef CONFIG_PCMCIA_M8XX
 177         /*Set up board specific hook-ups */
 178         m8xx_pcmcia_ops.hw_ctrl = pcmcia_hw_setup;
 179         m8xx_pcmcia_ops.voltage_set = pcmcia_set_voltage;
 180 #endif
 181 }
 182
 183 static void init_fec1_ioports(struct fs_platform_info *ptr)
 184 {
 185         cpm8xx_t *cp = (cpm8xx_t *) immr_map(im_cpm);
 186         iop8xx_t *io_port = (iop8xx_t *) immr_map(im_ioport);
 187
 188         /* configure FEC1 pins  */
 189         setbits16(&io_port->iop_papar, 0xf830);
 190         setbits16(&io_port->iop_padir, 0x0830);
 191         clrbits16(&io_port->iop_padir, 0xf000);
 192
 193         setbits32(&cp->cp_pbpar, 0x00001001);
 194         clrbits32(&cp->cp_pbdir, 0x00001001);
 195
 196         setbits16(&io_port->iop_pcpar, 0x000c);
 197         clrbits16(&io_port->iop_pcdir, 0x000c);
 198
 199         setbits32(&cp->cp_pepar, 0x00000003);
 200         setbits32(&cp->cp_pedir, 0x00000003);
 201         clrbits32(&cp->cp_peso, 0x00000003);
 202         clrbits32(&cp->cp_cptr, 0x00000100);
 203
 204         immr_unmap(io_port);
 205         immr_unmap(cp);
 206 }
 207
 208 static void init_fec2_ioports(struct fs_platform_info *ptr)
 209 {
 210         cpm8xx_t *cp = (cpm8xx_t *) immr_map(im_cpm);
 211         iop8xx_t *io_port = (iop8xx_t *) immr_map(im_ioport);
 212
 213         /* configure FEC2 pins */
 214         setbits32(&cp->cp_pepar, 0x0003fffc);
 215         setbits32(&cp->cp_pedir, 0x0003fffc);
 216         clrbits32(&cp->cp_peso, 0x000087fc);
 217         setbits32(&cp->cp_peso, 0x00037800);
 218         clrbits32(&cp->cp_cptr, 0x00000080);
 219
 220         immr_unmap(io_port);
 221         immr_unmap(cp);
 222 }
 223
 224 void init_fec_ioports(struct fs_platform_info *fpi)
 225 {
 226         int fec_no = fs_get_fec_index(fpi->fs_no);
 227
 228         switch (fec_no) {
 229         case 0:
 230                 init_fec1_ioports(fpi);
 231                 break;
 232         case 1:
 233                 init_fec2_ioports(fpi);
 234                 break;
 235         default:
 236                 printk(KERN_ERR "init_fec_ioports: invalid FEC number\n");
 237                 return;
 238         }
 239 }
 240
 241 static void init_scc3_ioports(struct fs_platform_info *fpi)
 242 {
 243         unsigned *bcsr_io;
 244         iop8xx_t *io_port;
 245         cpm8xx_t *cp;
 246
 247         bcsr_io = ioremap(BCSR_ADDR, BCSR_SIZE);
 248         io_port = (iop8xx_t *) immr_map(im_ioport);
 249         cp = (cpm8xx_t *) immr_map(im_cpm);
 250
 251         if (bcsr_io == NULL) {
 252                 printk(KERN_CRIT "Could not remap BCSR\n");
 253                 return;
 254         }
 255
 256         /* Enable the PHY.
 257          */
 258         clrbits32(bcsr_io + 4, BCSR4_ETH10_RST);
 259         udelay(1000);
 260         setbits32(bcsr_io + 4, BCSR4_ETH10_RST);
 261         /* Configure port A pins for Txd and Rxd.
 262          */
 263         setbits16(&io_port->iop_papar, PA_ENET_RXD | PA_ENET_TXD);
 264         clrbits16(&io_port->iop_padir, PA_ENET_RXD | PA_ENET_TXD);
 265
 266         /* Configure port C pins to enable CLSN and RENA.
 267          */
 268         clrbits16(&io_port->iop_pcpar, PC_ENET_CLSN | PC_ENET_RENA);
 269         clrbits16(&io_port->iop_pcdir, PC_ENET_CLSN | PC_ENET_RENA);
 270         setbits16(&io_port->iop_pcso, PC_ENET_CLSN | PC_ENET_RENA);
 271
 272         /* Configure port E for TCLK and RCLK.
 273          */
 274         setbits32(&cp->cp_pepar, PE_ENET_TCLK | PE_ENET_RCLK);
 275         clrbits32(&cp->cp_pepar, PE_ENET_TENA);
 276         clrbits32(&cp->cp_pedir, PE_ENET_TCLK | PE_ENET_RCLK | PE_ENET_TENA);
 277         clrbits32(&cp->cp_peso, PE_ENET_TCLK | PE_ENET_RCLK);
 278         setbits32(&cp->cp_peso, PE_ENET_TENA);
 279
 280         /* Configure Serial Interface clock routing.
 281          * First, clear all SCC bits to zero, then set the ones we want.
 282          */
 283         clrbits32(&cp->cp_sicr, SICR_ENET_MASK);
 284         setbits32(&cp->cp_sicr, SICR_ENET_CLKRT);
 285
 286         /* Disable Rx and Tx. SMC1 sshould be stopped if SCC3 eternet are used.
 287          */
 288         clrbits16(&cp->cp_smc[0].smc_smcmr, SMCMR_REN | SMCMR_TEN);
 289         /* On the MPC885ADS SCC ethernet PHY is initialized in the full duplex mode
 290          * by H/W setting after reset. SCC ethernet controller support only half duplex.
 291          * This discrepancy of modes causes a lot of carrier lost errors.
 292          */
 293
 294         /* In the original SCC enet driver the following code is placed at
 295            the end of the initialization */
 296         setbits32(&cp->cp_pepar, PE_ENET_TENA);
 297         clrbits32(&cp->cp_pedir, PE_ENET_TENA);
 298         setbits32(&cp->cp_peso, PE_ENET_TENA);
 299
 300         setbits32(bcsr_io + 4, BCSR1_ETHEN);
 301         iounmap(bcsr_io);
 302         immr_unmap(io_port);
 303         immr_unmap(cp);
 304 }
 305
 306 void init_scc_ioports(struct fs_platform_info *fpi)
 307 {
 308         int scc_no = fs_get_scc_index(fpi->fs_no);
 309
 310         switch (scc_no) {
 311         case 2:
 312                 init_scc3_ioports(fpi);
 313                 break;
 314         default:
 315                 printk(KERN_ERR "init_scc_ioports: invalid SCC number\n");
 316                 return;
 317         }
 318 }
 319
 320 static void init_smc1_uart_ioports(struct fs_uart_platform_info *ptr)
 321 {
 322         unsigned *bcsr_io;
 323         cpm8xx_t *cp;
 324
 325         cp = (cpm8xx_t *) immr_map(im_cpm);
 326         setbits32(&cp->cp_pepar, 0x000000c0);
 327         clrbits32(&cp->cp_pedir, 0x000000c0);
 328         clrbits32(&cp->cp_peso, 0x00000040);
 329         setbits32(&cp->cp_peso, 0x00000080);
 330         immr_unmap(cp);
 331
 332         bcsr_io = ioremap(BCSR1, sizeof(unsigned long));
 333
 334         if (bcsr_io == NULL) {
 335                 printk(KERN_CRIT "Could not remap BCSR1\n");
 336                 return;
 337         }
 338         clrbits32(bcsr_io, BCSR1_RS232EN_1);
 339         iounmap(bcsr_io);
 340 }
 341
 342 static void init_smc2_uart_ioports(struct fs_uart_platform_info *fpi)
 343 {
 344         unsigned *bcsr_io;
 345         cpm8xx_t *cp;
 346
 347         cp = (cpm8xx_t *) immr_map(im_cpm);
 348         setbits32(&cp->cp_pepar, 0x00000c00);
 349         clrbits32(&cp->cp_pedir, 0x00000c00);
 350         clrbits32(&cp->cp_peso, 0x00000400);
 351         setbits32(&cp->cp_peso, 0x00000800);
 352         immr_unmap(cp);
 353
 354         bcsr_io = ioremap(BCSR1, sizeof(unsigned long));
 355
 356         if (bcsr_io == NULL) {
 357                 printk(KERN_CRIT "Could not remap BCSR1\n");
 358                 return;
 359         }
 360         clrbits32(bcsr_io, BCSR1_RS232EN_2);
 361         iounmap(bcsr_io);
 362 }
 363
 364 void init_smc_ioports(struct fs_uart_platform_info *data)
 365 {
 366         int smc_no = fs_uart_id_fsid2smc(data->fs_no);
 367
 368         switch (smc_no) {
 369         case 0:
 370                 init_smc1_uart_ioports(data);
 371                 data->brg = data->clk_rx;
 372                 break;
 373         case 1:
 374                 init_smc2_uart_ioports(data);
 375                 data->brg = data->clk_rx;
 376                 break;
 377         default:
 378                 printk(KERN_ERR "init_scc_ioports: invalid SCC number\n");
 379                 return;
 380         }
 381 }
 382
 383 int platform_device_skip(const char *model, int id)
 384 {
 385 #ifdef CONFIG_MPC8xx_SECOND_ETH_SCC3
 386         const char *dev = "FEC";
 387         int n = 2;
 388 #else
 389         const char *dev = "SCC";
 390         int n = 3;
 391 #endif
 392
 393         if (!strcmp(model, dev) && n == id)
 394                 return 1;
 395
 396         return 0;
 397 }
 398
 399 static void __init mpc885ads_setup_arch(void)
 400 {
 401         cpm_reset();
 402
 403         mpc885ads_board_setup();
 404
 405         ROOT_DEV = Root_NFS;
 406 }
 407
 408 static int __init mpc885ads_probe(void)
 409 {
 410         char *model = of_get_flat_dt_prop(of_get_flat_dt_root(),
 411                                           "model", NULL);
 412         if (model == NULL)
 413                 return 0;
 414         if (strcmp(model, "MPC885ADS"))
 415                 return 0;
 416
 417         return 1;
 418 }
 419
 420 define_machine(mpc885_ads)
 421 {
 422         .name            = "MPC885 ADS",
 423         .probe           = mpc885ads_probe,
 424         .setup_arch      = mpc885ads_setup_arch,
 425         .init_IRQ        = m8xx_pic_init,
 426         .get_irq         = mpc8xx_get_irq,
 427         .restart         = mpc8xx_restart,
 428         .calibrate_decr  = mpc8xx_calibrate_decr,
 429         .set_rtc_time    = mpc8xx_set_rtc_time,
 430         .get_rtc_time    = mpc8xx_get_rtc_time,
 431 };