arch/mips/powertv/asic/asic_devices.c

   1 /*
   2  *
   3  * Description:  Defines the platform resources for Gaia-based settops.
   4  *
   5  * Copyright (C) 2005-2009 Scientific-Atlanta, Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  20  *
  21  * NOTE: The bootloader allocates persistent memory at an address which is
  22  * 16 MiB below the end of the highest address in KSEG0. All fixed
  23  * address memory reservations must avoid this region.
  24  */
  25
  26 #include <linux/device.h>
  27 #include <linux/kernel.h>
  28 #include <linux/init.h>
  29 #include <linux/resource.h>
  30 #include <linux/serial_reg.h>
  31 #include <linux/io.h>
  32 #include <linux/bootmem.h>
  33 #include <linux/mm.h>
  34 #include <linux/platform_device.h>
  35 #include <linux/module.h>
  36 #include <asm/page.h>
  37 #include <linux/swap.h>
  38 #include <linux/highmem.h>
  39 #include <linux/dma-mapping.h>
  40
  41 #include <asm/mach-powertv/asic.h>
  42 #include <asm/mach-powertv/asic_regs.h>
  43 #include <asm/mach-powertv/interrupts.h>
  44
  45 #ifdef CONFIG_BOOTLOADER_DRIVER
  46 #include <asm/mach-powertv/kbldr.h>
  47 #endif
  48 #include <asm/bootinfo.h>
  49
  50 #define BOOTLDRFAMILY(byte1, byte0) (((byte1) << 8) | (byte0))
  51
  52 /*
  53  * Forward Prototypes
  54  */
  55 static void pmem_setup_resource(void);
  56
  57 /*
  58  * Global Variables
  59  */
  60 enum asic_type asic;
  61
  62 unsigned int platform_features;
  63 unsigned int platform_family;
  64 struct register_map _asic_register_map;
  65 EXPORT_SYMBOL(_asic_register_map);              /* Exported for testing */
  66 unsigned long asic_phy_base;
  67 unsigned long asic_base;
  68 EXPORT_SYMBOL(asic_base);                       /* Exported for testing */
  69 struct resource *gp_resources;
  70
  71 /*
  72  * Don't recommend to use it directly, it is usually used by kernel internally.
  73  * Portable code should be using interfaces such as ioremp, dma_map_single, etc.
  74  */
  75 unsigned long phys_to_dma_offset;
  76 EXPORT_SYMBOL(phys_to_dma_offset);
  77
  78 /*
  79  *
  80  * IO Resource Definition
  81  *
  82  */
  83
  84 struct resource asic_resource = {
  85         .name  = "ASIC Resource",
  86         .start = 0,
  87         .end   = ASIC_IO_SIZE,
  88         .flags = IORESOURCE_MEM,
  89 };
  90
  91 /*
  92  * Allow override of bootloader-specified model
  93  * Returns zero on success, a negative errno value on failure.  This parameter
  94  * allows overriding of the bootloader-specified model.
  95  */
  96 static char __initdata cmdline[COMMAND_LINE_SIZE];
  97
  98 #define FORCEFAMILY_PARAM       "forcefamily"
  99
 100 /*
 101  * check_forcefamily - check for, and parse, forcefamily command line parameter
 102  * @forced_family:      Pointer to two-character array in which to store the
 103  *                      value of the forcedfamily parameter, if any.
 104  */
 105 static __init int check_forcefamily(unsigned char forced_family[2])
 106 {
 107         const char *p;
 108
 109         forced_family[0] = '\0';
 110         forced_family[1] = '\0';
 111
 112         /* Check the command line for a forcefamily directive */
 113         strncpy(cmdline, arcs_cmdline, COMMAND_LINE_SIZE - 1);
 114         p = strstr(cmdline, FORCEFAMILY_PARAM);
 115         if (p && (p != cmdline) && (*(p - 1) != ' '))
 116                 p = strstr(p, " " FORCEFAMILY_PARAM "=");
 117
 118         if (p) {
 119                 p += strlen(FORCEFAMILY_PARAM "=");
 120
 121                 if (*p == '\0' || *(p + 1) == '\0' ||
 122                         (*(p + 2) != '\0' && *(p + 2) != ' '))
 123                         pr_err(FORCEFAMILY_PARAM " must be exactly two "
 124                                 "characters long, ignoring value\n");
 125
 126                 else {
 127                         forced_family[0] = *p;
 128                         forced_family[1] = *(p + 1);
 129                 }
 130         }
 131
 132         return 0;
 133 }
 134
 135 /*
 136  * platform_set_family - determine major platform family type.
 137  *
 138  * Returns family type; -1 if none
 139  * Returns the family type; -1 if none
 140  *
 141  */
 142 static __init noinline void platform_set_family(void)
 143 {
 144         unsigned char forced_family[2];
 145         unsigned short bootldr_family;
 146
 147         if (check_forcefamily(forced_family) == 0)
 148                 bootldr_family = BOOTLDRFAMILY(forced_family[0],
 149                         forced_family[1]);
 150         else {
 151
 152 #ifdef CONFIG_BOOTLOADER_DRIVER
 153                 bootldr_family = (unsigned short) kbldr_GetSWFamily();
 154 #else
 155 #if defined(CONFIG_BOOTLOADER_FAMILY)
 156                 bootldr_family = (unsigned short) BOOTLDRFAMILY(
 157                         CONFIG_BOOTLOADER_FAMILY[0],
 158                         CONFIG_BOOTLOADER_FAMILY[1]);
 159 #else
 160 #error "Unknown Bootloader Family"
 161 #endif
 162 #endif
 163         }
 164
 165         pr_info("Bootloader Family = 0x%04X\n", bootldr_family);
 166
 167         switch (bootldr_family) {
 168         case BOOTLDRFAMILY('R', '1'):
 169                 platform_family = FAMILY_1500;
 170                 break;
 171         case BOOTLDRFAMILY('4', '4'):
 172                 platform_family = FAMILY_4500;
 173                 break;
 174         case BOOTLDRFAMILY('4', '6'):
 175                 platform_family = FAMILY_4600;
 176                 break;
 177         case BOOTLDRFAMILY('A', '1'):
 178                 platform_family = FAMILY_4600VZA;
 179                 break;
 180         case BOOTLDRFAMILY('8', '5'):
 181                 platform_family = FAMILY_8500;
 182                 break;
 183         case BOOTLDRFAMILY('R', '2'):
 184                 platform_family = FAMILY_8500RNG;
 185                 break;
 186         case BOOTLDRFAMILY('8', '6'):
 187                 platform_family = FAMILY_8600;
 188                 break;
 189         case BOOTLDRFAMILY('B', '1'):
 190                 platform_family = FAMILY_8600VZB;
 191                 break;
 192         case BOOTLDRFAMILY('E', '1'):
 193                 platform_family = FAMILY_1500VZE;
 194                 break;
 195         case BOOTLDRFAMILY('F', '1'):
 196                 platform_family = FAMILY_1500VZF;
 197                 break;
 198         case BOOTLDRFAMILY('8', '7'):
 199                 platform_family = FAMILY_8700;
 200                 break;
 201         default:
 202                 platform_family = -1;
 203         }
 204 }
 205
 206 unsigned int platform_get_family(void)
 207 {
 208         return platform_family;
 209 }
 210 EXPORT_SYMBOL(platform_get_family);
 211
 212 /*
 213  * platform_get_asic - determine the ASIC type.
 214  *
 215  * Returns the ASIC type, or ASIC_UNKNOWN if unknown
 216  *
 217  */
 218 enum asic_type platform_get_asic(void)
 219 {
 220         return asic;
 221 }
 222 EXPORT_SYMBOL(platform_get_asic);
 223
 224 /*
 225  * set_register_map - set ASIC register configuration
 226  * @phys_base:  Physical address of the base of the ASIC registers
 227  * @map:        Description of key ASIC registers
 228  */
 229 static void __init set_register_map(unsigned long phys_base,
 230         const struct register_map *map)
 231 {
 232         asic_phy_base = phys_base;
 233         _asic_register_map = *map;
 234         register_map_virtualize(&_asic_register_map);
 235         asic_base = (unsigned long)ioremap_nocache(phys_base, ASIC_IO_SIZE);
 236 }
 237
 238 /**
 239  * configure_platform - configuration based on platform type.
 240  */
 241 void __init configure_platform(void)
 242 {
 243         platform_set_family();
 244
 245         switch (platform_family) {
 246         case FAMILY_1500:
 247         case FAMILY_1500VZE:
 248         case FAMILY_1500VZF:
 249                 platform_features = FFS_CAPABLE;
 250                 asic = ASIC_CALLIOPE;
 251                 set_register_map(CALLIOPE_IO_BASE, &calliope_register_map);
 252
 253                 if (platform_family == FAMILY_1500VZE) {
 254                         gp_resources = non_dvr_vze_calliope_resources;
 255                         pr_info("Platform: 1500/Vz Class E - "
 256                                 "CALLIOPE, NON_DVR_CAPABLE\n");
 257                 } else if (platform_family == FAMILY_1500VZF) {
 258                         gp_resources = non_dvr_vzf_calliope_resources;
 259                         pr_info("Platform: 1500/Vz Class F - "
 260                                 "CALLIOPE, NON_DVR_CAPABLE\n");
 261                 } else {
 262                         gp_resources = non_dvr_calliope_resources;
 263                         pr_info("Platform: 1500/RNG100 - CALLIOPE, "
 264                                 "NON_DVR_CAPABLE\n");
 265                 }
 266                 break;
 267
 268         case FAMILY_4500:
 269                 platform_features = FFS_CAPABLE | PCIE_CAPABLE |
 270                         DISPLAY_CAPABLE;
 271                 asic = ASIC_ZEUS;
 272                 set_register_map(ZEUS_IO_BASE, &zeus_register_map);
 273                 gp_resources = non_dvr_zeus_resources;
 274
 275                 pr_info("Platform: 4500 - ZEUS, NON_DVR_CAPABLE\n");
 276                 break;
 277
 278         case FAMILY_4600:
 279         {
 280                 unsigned int chipversion = 0;
 281
 282                 /* The settop has PCIE but it isn't used, so don't advertise
 283                  * it*/
 284                 platform_features = FFS_CAPABLE | DISPLAY_CAPABLE;
 285
 286                 /* Cronus and Cronus Lite have the same register map */
 287                 set_register_map(CRONUS_IO_BASE, &cronus_register_map);
 288
 289                 /* ASIC version will determine if this is a real CronusLite or
 290                  * Castrati(Cronus) */
 291                 chipversion  = asic_read(chipver3) << 24;
 292                 chipversion |= asic_read(chipver2) << 16;
 293                 chipversion |= asic_read(chipver1) << 8;
 294                 chipversion |= asic_read(chipver0);
 295
 296                 if ((chipversion == CRONUS_10) || (chipversion == CRONUS_11))
 297                         asic = ASIC_CRONUS;
 298                 else
 299                         asic = ASIC_CRONUSLITE;
 300
 301                 gp_resources = non_dvr_cronuslite_resources;
 302                 pr_info("Platform: 4600 - %s, NON_DVR_CAPABLE, "
 303                         "chipversion=0x%08X\n",
 304                         (asic == ASIC_CRONUS) ? "CRONUS" : "CRONUS LITE",
 305                         chipversion);
 306                 break;
 307         }
 308         case FAMILY_4600VZA:
 309                 platform_features = FFS_CAPABLE | DISPLAY_CAPABLE;
 310                 asic = ASIC_CRONUS;
 311                 set_register_map(CRONUS_IO_BASE, &cronus_register_map);
 312                 gp_resources = non_dvr_cronus_resources;
 313
 314                 pr_info("Platform: Vz Class A - CRONUS, NON_DVR_CAPABLE\n");
 315                 break;
 316
 317         case FAMILY_8500:
 318         case FAMILY_8500RNG:
 319                 platform_features = DVR_CAPABLE | PCIE_CAPABLE |
 320                         DISPLAY_CAPABLE;
 321                 asic = ASIC_ZEUS;
 322                 set_register_map(ZEUS_IO_BASE, &zeus_register_map);
 323                 gp_resources = dvr_zeus_resources;
 324
 325                 pr_info("Platform: 8500/RNG200 - ZEUS, DVR_CAPABLE\n");
 326                 break;
 327
 328         case FAMILY_8600:
 329         case FAMILY_8600VZB:
 330                 platform_features = DVR_CAPABLE | PCIE_CAPABLE |
 331                         DISPLAY_CAPABLE;
 332                 asic = ASIC_CRONUS;
 333                 set_register_map(CRONUS_IO_BASE, &cronus_register_map);
 334                 gp_resources = dvr_cronus_resources;
 335
 336                 pr_info("Platform: 8600/Vz Class B - CRONUS, "
 337                         "DVR_CAPABLE\n");
 338                 break;
 339
 340         case FAMILY_8700:
 341                 platform_features = FFS_CAPABLE | PCIE_CAPABLE;
 342                 asic = ASIC_GAIA;
 343                 set_register_map(GAIA_IO_BASE, &gaia_register_map);
 344                 gp_resources = dvr_gaia_resources;
 345
 346                 pr_info("Platform: 8700 - GAIA, DVR_CAPABLE\n");
 347                 break;
 348
 349         default:
 350                 pr_crit("Platform:  UNKNOWN PLATFORM\n");
 351                 break;
 352         }
 353
 354         switch (asic) {
 355         case ASIC_ZEUS:
 356                 phys_to_dma_offset = 0x30000000;
 357                 break;
 358         case ASIC_CALLIOPE:
 359                 phys_to_dma_offset = 0x10000000;
 360                 break;
 361         case ASIC_CRONUSLITE:
 362                 /* Fall through */
 363         case ASIC_CRONUS:
 364                 /*
 365                  * TODO: We suppose 0x10000000 aliases into 0x20000000-
 366                  * 0x2XXXXXXX. If 0x10000000 aliases into 0x60000000-
 367                  * 0x6XXXXXXX, the offset should be 0x50000000, not 0x10000000.
 368                  */
 369                 phys_to_dma_offset = 0x10000000;
 370                 break;
 371         default:
 372                 phys_to_dma_offset = 0x00000000;
 373                 break;
 374         }
 375 }
 376
 377 /*
 378  * RESOURCE ALLOCATION
 379  *
 380  */
 381 /*
 382  * Allocates/reserves the Platform memory resources early in the boot process.
 383  * This ignores any resources that are designated IORESOURCE_IO
 384  */
 385 void __init platform_alloc_bootmem(void)
 386 {
 387         int i;
 388         int total = 0;
 389
 390         /* Get persistent memory data from command line before allocating
 391          * resources. This need to happen before normal command line parsing
 392          * has been done */
 393         pmem_setup_resource();
 394
 395         /* Loop through looking for resources that want a particular address */
 396         for (i = 0; gp_resources[i].flags != 0; i++) {
 397                 int size = gp_resources[i].end - gp_resources[i].start + 1;
 398                 if ((gp_resources[i].start != 0) &&
 399                         ((gp_resources[i].flags & IORESOURCE_MEM) != 0)) {
 400                         reserve_bootmem(dma_to_phys(gp_resources[i].start),
 401                                 size, 0);
 402                         total += gp_resources[i].end -
 403                                 gp_resources[i].start + 1;
 404                         pr_info("reserve resource %s at %08x (%u bytes)\n",
 405                                 gp_resources[i].name, gp_resources[i].start,
 406                                 gp_resources[i].end -
 407                                         gp_resources[i].start + 1);
 408                 }
 409         }
 410
 411         /* Loop through assigning addresses for those that are left */
 412         for (i = 0; gp_resources[i].flags != 0; i++) {
 413                 int size = gp_resources[i].end - gp_resources[i].start + 1;
 414                 if ((gp_resources[i].start == 0) &&
 415                         ((gp_resources[i].flags & IORESOURCE_MEM) != 0)) {
 416                         void *mem = alloc_bootmem_pages(size);
 417
 418                         if (mem == NULL)
 419                                 pr_err("Unable to allocate bootmem pages "
 420                                         "for %s\n", gp_resources[i].name);
 421
 422                         else {
 423                                 gp_resources[i].start =
 424                                         phys_to_dma(virt_to_phys(mem));
 425                                 gp_resources[i].end =
 426                                         gp_resources[i].start + size - 1;
 427                                 total += size;
 428                                 pr_info("allocate resource %s at %08x "
 429                                                 "(%u bytes)\n",
 430                                         gp_resources[i].name,
 431                                         gp_resources[i].start, size);
 432                         }
 433                 }
 434         }
 435
 436         pr_info("Total Platform driver memory allocation: 0x%08x\n", total);
 437
 438         /* indicate resources that are platform I/O related */
 439         for (i = 0; gp_resources[i].flags != 0; i++) {
 440                 if ((gp_resources[i].start != 0) &&
 441                         ((gp_resources[i].flags & IORESOURCE_IO) != 0)) {
 442                         pr_info("reserved platform resource %s at %08x\n",
 443                                 gp_resources[i].name, gp_resources[i].start);
 444                 }
 445         }
 446 }
 447
 448 /*
 449  *
 450  * PERSISTENT MEMORY (PMEM) CONFIGURATION
 451  *
 452  */
 453 static unsigned long pmemaddr __initdata;
 454
 455 static int __init early_param_pmemaddr(char *p)
 456 {
 457         pmemaddr = (unsigned long)simple_strtoul(p, NULL, 0);
 458         return 0;
 459 }
 460 early_param("pmemaddr", early_param_pmemaddr);
 461
 462 static long pmemlen __initdata;
 463
 464 static int __init early_param_pmemlen(char *p)
 465 {
 466 /* TODO: we can use this code when and if the bootloader ever changes this */
 467 #if 0
 468         pmemlen = (unsigned long)simple_strtoul(p, NULL, 0);
 469 #else
 470         pmemlen = 0x20000;
 471 #endif
 472         return 0;
 473 }
 474 early_param("pmemlen", early_param_pmemlen);
 475
 476 /*
 477  * Set up persistent memory. If we were given values, we patch the array of
 478  * resources. Otherwise, persistent memory may be allocated anywhere at all.
 479  */
 480 static void __init pmem_setup_resource(void)
 481 {
 482         struct resource *resource;
 483         resource = asic_resource_get("DiagPersistentMemory");
 484
 485         if (resource && pmemaddr && pmemlen) {
 486                 /* The address provided by bootloader is in kseg0. Convert to
 487                  * a bus address. */
 488                 resource->start = phys_to_dma(pmemaddr - 0x80000000);
 489                 resource->end = resource->start + pmemlen - 1;
 490
 491                 pr_info("persistent memory: start=0x%x  end=0x%x\n",
 492                         resource->start, resource->end);
 493         }
 494 }
 495
 496 /*
 497  *
 498  * RESOURCE ACCESS FUNCTIONS
 499  *
 500  */
 501
 502 /**
 503  * asic_resource_get - retrieves parameters for a platform resource.
 504  * @name:       string to match resource
 505  *
 506  * Returns a pointer to a struct resource corresponding to the given name.
 507  *
 508  * CANNOT BE NAMED platform_resource_get, which would be the obvious choice,
 509  * as this function name is already declared
 510  */
 511 struct resource *asic_resource_get(const char *name)
 512 {
 513         int i;
 514
 515         for (i = 0; gp_resources[i].flags != 0; i++) {
 516                 if (strcmp(gp_resources[i].name, name) == 0)
 517                         return &gp_resources[i];
 518         }
 519
 520         return NULL;
 521 }
 522 EXPORT_SYMBOL(asic_resource_get);
 523
 524 /**
 525  * platform_release_memory - release pre-allocated memory
 526  * @ptr:        pointer to memory to release
 527  * @size:       size of resource
 528  *
 529  * This must only be called for memory allocated or reserved via the boot
 530  * memory allocator.
 531  */
 532 void platform_release_memory(void *ptr, int size)
 533 {
 534         unsigned long addr;
 535         unsigned long end;
 536
 537         addr = ((unsigned long)ptr + (PAGE_SIZE - 1)) & PAGE_MASK;
 538         end = ((unsigned long)ptr + size) & PAGE_MASK;
 539
 540         for (; addr < end; addr += PAGE_SIZE) {
 541                 ClearPageReserved(virt_to_page(__va(addr)));
 542                 init_page_count(virt_to_page(__va(addr)));
 543                 free_page((unsigned long)__va(addr));
 544         }
 545 }
 546 EXPORT_SYMBOL(platform_release_memory);
 547
 548 /*
 549  *
 550  * FEATURE AVAILABILITY FUNCTIONS
 551  *
 552  */
 553 int platform_supports_dvr(void)
 554 {
 555         return (platform_features & DVR_CAPABLE) != 0;
 556 }
 557
 558 int platform_supports_ffs(void)
 559 {
 560         return (platform_features & FFS_CAPABLE) != 0;
 561 }
 562
 563 int platform_supports_pcie(void)
 564 {
 565         return (platform_features & PCIE_CAPABLE) != 0;
 566 }
 567
 568 int platform_supports_display(void)
 569 {
 570         return (platform_features & DISPLAY_CAPABLE) != 0;
 571 }