MIPS: PowerTV: Separate PowerTV USB support from non-USB code
[sfrench/cifs-2.6.git] / 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 }