MIPS: PowerTV: Add Gaia platform definitions.
[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 <linux/gfp.h>
37 #include <asm/page.h>
38 #include <linux/swap.h>
39 #include <linux/highmem.h>
40 #include <linux/dma-mapping.h>
41
42 #include <asm/mach-powertv/asic.h>
43 #include <asm/mach-powertv/asic_regs.h>
44 #include <asm/mach-powertv/interrupts.h>
45
46 #ifdef CONFIG_BOOTLOADER_DRIVER
47 #include <asm/mach-powertv/kbldr.h>
48 #endif
49 #include <asm/bootinfo.h>
50
51 #define BOOTLDRFAMILY(byte1, byte0) (((byte1) << 8) | (byte0))
52
53 /*
54  * Forward Prototypes
55  */
56 static void pmem_setup_resource(void);
57
58 /*
59  * Global Variables
60  */
61 enum asic_type asic;
62
63 unsigned int platform_features;
64 unsigned int platform_family;
65 struct register_map _asic_register_map;
66 EXPORT_SYMBOL(_asic_register_map);              /* Exported for testing */
67 unsigned long asic_phy_base;
68 unsigned long asic_base;
69 EXPORT_SYMBOL(asic_base);                       /* Exported for testing */
70 struct resource *gp_resources;
71 static bool usb_configured;
72
73 /*
74  * Don't recommend to use it directly, it is usually used by kernel internally.
75  * Portable code should be using interfaces such as ioremp, dma_map_single, etc.
76  */
77 unsigned long phys_to_dma_offset;
78 EXPORT_SYMBOL(phys_to_dma_offset);
79
80 /*
81  *
82  * IO Resource Definition
83  *
84  */
85
86 struct resource asic_resource = {
87         .name  = "ASIC Resource",
88         .start = 0,
89         .end   = ASIC_IO_SIZE,
90         .flags = IORESOURCE_MEM,
91 };
92
93 /*
94  *
95  * USB Host Resource Definition
96  *
97  */
98
99 static struct resource ehci_resources[] = {
100         {
101                 .parent = &asic_resource,
102                 .start  = 0,
103                 .end    = 0xff,
104                 .flags  = IORESOURCE_MEM,
105         },
106         {
107                 .start  = irq_usbehci,
108                 .end    = irq_usbehci,
109                 .flags  = IORESOURCE_IRQ,
110         },
111 };
112
113 static u64 ehci_dmamask = DMA_BIT_MASK(32);
114
115 static struct platform_device ehci_device = {
116         .name = "powertv-ehci",
117         .id = 0,
118         .num_resources = 2,
119         .resource = ehci_resources,
120         .dev = {
121                 .dma_mask = &ehci_dmamask,
122                 .coherent_dma_mask = DMA_BIT_MASK(32),
123         },
124 };
125
126 static struct resource ohci_resources[] = {
127         {
128                 .parent = &asic_resource,
129                 .start  = 0,
130                 .end    = 0xff,
131                 .flags  = IORESOURCE_MEM,
132         },
133         {
134                 .start  = irq_usbohci,
135                 .end    = irq_usbohci,
136                 .flags  = IORESOURCE_IRQ,
137         },
138 };
139
140 static u64 ohci_dmamask = DMA_BIT_MASK(32);
141
142 static struct platform_device ohci_device = {
143         .name = "powertv-ohci",
144         .id = 0,
145         .num_resources = 2,
146         .resource = ohci_resources,
147         .dev = {
148                 .dma_mask = &ohci_dmamask,
149                 .coherent_dma_mask = DMA_BIT_MASK(32),
150         },
151 };
152
153 static struct platform_device *platform_devices[] = {
154         &ehci_device,
155         &ohci_device,
156 };
157
158 /*
159  *
160  * Platform Configuration and Device Initialization
161  *
162  */
163 static void __init fs_update(int pe, int md, int sdiv, int disable_div_by_3)
164 {
165         int en_prg, byp, pwr, nsb, val;
166         int sout;
167
168         sout = 1;
169         en_prg = 1;
170         byp = 0;
171         nsb = 1;
172         pwr = 1;
173
174         val = ((sdiv << 29) | (md << 24) | (pe<<8) | (sout<<3) | (byp<<2) |
175                 (nsb<<1) | (disable_div_by_3<<5));
176
177         asic_write(val, fs432x4b4_usb_ctl);
178         asic_write(val | (en_prg<<4), fs432x4b4_usb_ctl);
179         asic_write(val | (en_prg<<4) | pwr, fs432x4b4_usb_ctl);
180 }
181
182 /*
183  * Allow override of bootloader-specified model
184  */
185 static char __initdata cmdline[COMMAND_LINE_SIZE];
186
187 #define FORCEFAMILY_PARAM       "forcefamily"
188
189 static __init int check_forcefamily(unsigned char forced_family[2])
190 {
191         const char *p;
192
193         forced_family[0] = '\0';
194         forced_family[1] = '\0';
195
196         /* Check the command line for a forcefamily directive */
197         strncpy(cmdline, arcs_cmdline, COMMAND_LINE_SIZE - 1);
198         p = strstr(cmdline, FORCEFAMILY_PARAM);
199         if (p && (p != cmdline) && (*(p - 1) != ' '))
200                 p = strstr(p, " " FORCEFAMILY_PARAM "=");
201
202         if (p) {
203                 p += strlen(FORCEFAMILY_PARAM "=");
204
205                 if (*p == '\0' || *(p + 1) == '\0' ||
206                         (*(p + 2) != '\0' && *(p + 2) != ' '))
207                         pr_err(FORCEFAMILY_PARAM " must be exactly two "
208                                 "characters long, ignoring value\n");
209
210                 else {
211                         forced_family[0] = *p;
212                         forced_family[1] = *(p + 1);
213                 }
214         }
215
216         return 0;
217 }
218
219 /*
220  * platform_set_family - determine major platform family type.
221  *
222  * Returns family type; -1 if none
223  * Returns the family type; -1 if none
224  *
225  */
226 static __init noinline void platform_set_family(void)
227 {
228 #define BOOTLDRFAMILY(byte1, byte0) (((byte1) << 8) | (byte0))
229
230         unsigned char forced_family[2];
231         unsigned short bootldr_family;
232
233         check_forcefamily(forced_family);
234
235         if (forced_family[0] != '\0' && forced_family[1] != '\0')
236                 bootldr_family = BOOTLDRFAMILY(forced_family[0],
237                         forced_family[1]);
238         else {
239
240 #ifdef CONFIG_BOOTLOADER_DRIVER
241                 bootldr_family = (unsigned short) kbldr_GetSWFamily();
242 #else
243 #if defined(CONFIG_BOOTLOADER_FAMILY)
244                 bootldr_family = (unsigned short) BOOTLDRFAMILY(
245                         CONFIG_BOOTLOADER_FAMILY[0],
246                         CONFIG_BOOTLOADER_FAMILY[1]);
247 #else
248 #error "Unknown Bootloader Family"
249 #endif
250 #endif
251         }
252
253         pr_info("Bootloader Family = 0x%04X\n", bootldr_family);
254
255         switch (bootldr_family) {
256         case BOOTLDRFAMILY('R', '1'):
257                 platform_family = FAMILY_1500;
258                 break;
259         case BOOTLDRFAMILY('4', '4'):
260                 platform_family = FAMILY_4500;
261                 break;
262         case BOOTLDRFAMILY('4', '6'):
263                 platform_family = FAMILY_4600;
264                 break;
265         case BOOTLDRFAMILY('A', '1'):
266                 platform_family = FAMILY_4600VZA;
267                 break;
268         case BOOTLDRFAMILY('8', '5'):
269                 platform_family = FAMILY_8500;
270                 break;
271         case BOOTLDRFAMILY('R', '2'):
272                 platform_family = FAMILY_8500RNG;
273                 break;
274         case BOOTLDRFAMILY('8', '6'):
275                 platform_family = FAMILY_8600;
276                 break;
277         case BOOTLDRFAMILY('B', '1'):
278                 platform_family = FAMILY_8600VZB;
279                 break;
280         case BOOTLDRFAMILY('E', '1'):
281                 platform_family = FAMILY_1500VZE;
282                 break;
283         case BOOTLDRFAMILY('F', '1'):
284                 platform_family = FAMILY_1500VZF;
285                 break;
286         case BOOTLDRFAMILY('8', '7'):
287                 platform_family = FAMILY_8700;
288                 break;
289         default:
290                 platform_family = -1;
291         }
292 }
293
294 unsigned int platform_get_family(void)
295 {
296         return platform_family;
297 }
298 EXPORT_SYMBOL(platform_get_family);
299
300 /*
301  * \brief usb_eye_configure() for optimizing the USB eye on Calliope.
302  *
303  * \param     unsigned int value saved to the register.
304  *
305  * \return    none
306  *
307  */
308 static void __init usb_eye_configure(unsigned int value)
309 {
310         asic_write(asic_read(crt_spare) | value, crt_spare);
311 }
312
313 /*
314  * platform_get_asic - determine the ASIC type.
315  *
316  * \param     none
317  *
318  * \return    ASIC type; ASIC_UNKNOWN if none
319  *
320  */
321 enum asic_type platform_get_asic(void)
322 {
323         return asic;
324 }
325 EXPORT_SYMBOL(platform_get_asic);
326
327 /*
328  * platform_configure_usb - usb configuration based on platform type.
329  * @bcm1_usb2_ctl:      value for the BCM1_USB2_CTL register, which is
330  *                      quirky
331  */
332 static void __init platform_configure_usb(void)
333 {
334         u32 bcm1_usb2_ctl;
335
336         if (usb_configured)
337                 return;
338
339         switch (asic) {
340         case ASIC_ZEUS:
341         case ASIC_CRONUS:
342         case ASIC_CRONUSLITE:
343                 fs_update(0x0000, 0x11, 0x02, 0);
344                 bcm1_usb2_ctl = 0x803;
345                 break;
346
347         case ASIC_CALLIOPE:
348                 fs_update(0x0000, 0x11, 0x02, 1);
349
350                 switch (platform_family) {
351                 case FAMILY_1500VZE:
352                         break;
353
354                 case FAMILY_1500VZF:
355                         usb_eye_configure(0x003c0000);
356                         break;
357
358                 default:
359                         usb_eye_configure(0x00300000);
360                         break;
361                 }
362
363                 bcm1_usb2_ctl = 0x803;
364                 break;
365
366         default:
367                 pr_err("Unknown ASIC type: %d\n", asic);
368                 break;
369         }
370
371         /* turn on USB power */
372         asic_write(0, usb2_strap);
373         /* Enable all OHCI interrupts */
374         asic_write(bcm1_usb2_ctl, usb2_control);
375         /* USB2_STBUS_OBC store32/load32 */
376         asic_write(3, usb2_stbus_obc);
377         /* USB2_STBUS_MESS_SIZE 2 packets */
378         asic_write(1, usb2_stbus_mess_size);
379         /* USB2_STBUS_CHUNK_SIZE 2 packets */
380         asic_write(1, usb2_stbus_chunk_size);
381
382         usb_configured = true;
383 }
384
385 /*
386  * Set up the USB EHCI interface
387  */
388 void platform_configure_usb_ehci()
389 {
390         platform_configure_usb();
391 }
392
393 /*
394  * Set up the USB OHCI interface
395  */
396 void platform_configure_usb_ohci()
397 {
398         platform_configure_usb();
399 }
400
401 /*
402  * Shut the USB EHCI interface down--currently a NOP
403  */
404 void platform_unconfigure_usb_ehci()
405 {
406 }
407
408 /*
409  * Shut the USB OHCI interface down--currently a NOP
410  */
411 void platform_unconfigure_usb_ohci()
412 {
413 }
414
415 static void __init set_register_map(unsigned long phys_base,
416         const struct register_map *map)
417 {
418         asic_phy_base = phys_base;
419         _asic_register_map = *map;
420         register_map_virtualize(&_asic_register_map);
421         asic_base = (unsigned long)ioremap_nocache(phys_base, ASIC_IO_SIZE);
422 }
423
424 /**
425  * configure_platform - configuration based on platform type.
426  */
427 void __init configure_platform(void)
428 {
429         platform_set_family();
430
431         switch (platform_family) {
432         case FAMILY_1500:
433         case FAMILY_1500VZE:
434         case FAMILY_1500VZF:
435                 platform_features = FFS_CAPABLE;
436                 asic = ASIC_CALLIOPE;
437                 set_register_map(CALLIOPE_IO_BASE, &calliope_register_map);
438
439                 if (platform_family == FAMILY_1500VZE) {
440                         gp_resources = non_dvr_vze_calliope_resources;
441                         pr_info("Platform: 1500/Vz Class E - "
442                                 "CALLIOPE, NON_DVR_CAPABLE\n");
443                 } else if (platform_family == FAMILY_1500VZF) {
444                         gp_resources = non_dvr_vzf_calliope_resources;
445                         pr_info("Platform: 1500/Vz Class F - "
446                                 "CALLIOPE, NON_DVR_CAPABLE\n");
447                 } else {
448                         gp_resources = non_dvr_calliope_resources;
449                         pr_info("Platform: 1500/RNG100 - CALLIOPE, "
450                                 "NON_DVR_CAPABLE\n");
451                 }
452                 break;
453
454         case FAMILY_4500:
455                 platform_features = FFS_CAPABLE | PCIE_CAPABLE |
456                         DISPLAY_CAPABLE;
457                 asic = ASIC_ZEUS;
458                 set_register_map(ZEUS_IO_BASE, &zeus_register_map);
459                 gp_resources = non_dvr_zeus_resources;
460
461                 pr_info("Platform: 4500 - ZEUS, NON_DVR_CAPABLE\n");
462                 break;
463
464         case FAMILY_4600:
465         {
466                 unsigned int chipversion = 0;
467
468                 /* The settop has PCIE but it isn't used, so don't advertise
469                  * it*/
470                 platform_features = FFS_CAPABLE | DISPLAY_CAPABLE;
471
472                 /* Cronus and Cronus Lite have the same register map */
473                 set_register_map(CRONUS_IO_BASE, &cronus_register_map);
474
475                 /* ASIC version will determine if this is a real CronusLite or
476                  * Castrati(Cronus) */
477                 chipversion  = asic_read(chipver3) << 24;
478                 chipversion |= asic_read(chipver2) << 16;
479                 chipversion |= asic_read(chipver1) << 8;
480                 chipversion |= asic_read(chipver0);
481
482                 if ((chipversion == CRONUS_10) || (chipversion == CRONUS_11))
483                         asic = ASIC_CRONUS;
484                 else
485                         asic = ASIC_CRONUSLITE;
486
487                 gp_resources = non_dvr_cronuslite_resources;
488                 pr_info("Platform: 4600 - %s, NON_DVR_CAPABLE, "
489                         "chipversion=0x%08X\n",
490                         (asic == ASIC_CRONUS) ? "CRONUS" : "CRONUS LITE",
491                         chipversion);
492                 break;
493         }
494         case FAMILY_4600VZA:
495                 platform_features = FFS_CAPABLE | DISPLAY_CAPABLE;
496                 asic = ASIC_CRONUS;
497                 set_register_map(CRONUS_IO_BASE, &cronus_register_map);
498                 gp_resources = non_dvr_cronus_resources;
499
500                 pr_info("Platform: Vz Class A - CRONUS, NON_DVR_CAPABLE\n");
501                 break;
502
503         case FAMILY_8500:
504         case FAMILY_8500RNG:
505                 platform_features = DVR_CAPABLE | PCIE_CAPABLE |
506                         DISPLAY_CAPABLE;
507                 asic = ASIC_ZEUS;
508                 set_register_map(ZEUS_IO_BASE, &zeus_register_map);
509                 gp_resources = dvr_zeus_resources;
510
511                 pr_info("Platform: 8500/RNG200 - ZEUS, DVR_CAPABLE\n");
512                 break;
513
514         case FAMILY_8600:
515         case FAMILY_8600VZB:
516                 platform_features = DVR_CAPABLE | PCIE_CAPABLE |
517                         DISPLAY_CAPABLE;
518                 asic = ASIC_CRONUS;
519                 set_register_map(CRONUS_IO_BASE, &cronus_register_map);
520                 gp_resources = dvr_cronus_resources;
521
522                 pr_info("Platform: 8600/Vz Class B - CRONUS, "
523                         "DVR_CAPABLE\n");
524                 break;
525
526         case FAMILY_8700:
527                 platform_features = FFS_CAPABLE | PCIE_CAPABLE;
528                 asic = ASIC_GAIA;
529                 set_register_map(GAIA_IO_BASE, &gaia_register_map);
530                 gp_resources = dvr_gaia_resources;
531
532                 pr_info("Platform: 8700 - GAIA, DVR_CAPABLE\n");
533                 break;
534
535         default:
536                 pr_crit("Platform:  UNKNOWN PLATFORM\n");
537                 break;
538         }
539
540         switch (asic) {
541         case ASIC_ZEUS:
542                 phys_to_dma_offset = 0x30000000;
543                 break;
544         case ASIC_CALLIOPE:
545                 phys_to_dma_offset = 0x10000000;
546                 break;
547         case ASIC_CRONUSLITE:
548                 /* Fall through */
549         case ASIC_CRONUS:
550                 /*
551                  * TODO: We suppose 0x10000000 aliases into 0x20000000-
552                  * 0x2XXXXXXX. If 0x10000000 aliases into 0x60000000-
553                  * 0x6XXXXXXX, the offset should be 0x50000000, not 0x10000000.
554                  */
555                 phys_to_dma_offset = 0x10000000;
556                 break;
557         default:
558                 phys_to_dma_offset = 0x00000000;
559                 break;
560         }
561 }
562
563 /**
564  * platform_devices_init - sets up USB device resourse.
565  */
566 static int __init platform_devices_init(void)
567 {
568         pr_notice("%s: ----- Initializing USB resources -----\n", __func__);
569
570         asic_resource.start = asic_phy_base;
571         asic_resource.end += asic_resource.start;
572
573         ehci_resources[0].start = asic_reg_phys_addr(ehci_hcapbase);
574         ehci_resources[0].end += ehci_resources[0].start;
575
576         ohci_resources[0].start = asic_reg_phys_addr(ohci_hc_revision);
577         ohci_resources[0].end += ohci_resources[0].start;
578
579         set_io_port_base(0);
580
581         platform_add_devices(platform_devices, ARRAY_SIZE(platform_devices));
582
583         return 0;
584 }
585
586 arch_initcall(platform_devices_init);
587
588 /*
589  *
590  * BOOTMEM ALLOCATION
591  *
592  */
593 /*
594  * Allocates/reserves the Platform memory resources early in the boot process.
595  * This ignores any resources that are designated IORESOURCE_IO
596  */
597 void __init platform_alloc_bootmem(void)
598 {
599         int i;
600         int total = 0;
601
602         /* Get persistent memory data from command line before allocating
603          * resources. This need to happen before normal command line parsing
604          * has been done */
605         pmem_setup_resource();
606
607         /* Loop through looking for resources that want a particular address */
608         for (i = 0; gp_resources[i].flags != 0; i++) {
609                 int size = gp_resources[i].end - gp_resources[i].start + 1;
610                 if ((gp_resources[i].start != 0) &&
611                         ((gp_resources[i].flags & IORESOURCE_MEM) != 0)) {
612                         reserve_bootmem(dma_to_phys(gp_resources[i].start),
613                                 size, 0);
614                         total += gp_resources[i].end -
615                                 gp_resources[i].start + 1;
616                         pr_info("reserve resource %s at %08x (%u bytes)\n",
617                                 gp_resources[i].name, gp_resources[i].start,
618                                 gp_resources[i].end -
619                                         gp_resources[i].start + 1);
620                 }
621         }
622
623         /* Loop through assigning addresses for those that are left */
624         for (i = 0; gp_resources[i].flags != 0; i++) {
625                 int size = gp_resources[i].end - gp_resources[i].start + 1;
626                 if ((gp_resources[i].start == 0) &&
627                         ((gp_resources[i].flags & IORESOURCE_MEM) != 0)) {
628                         void *mem = alloc_bootmem_pages(size);
629
630                         if (mem == NULL)
631                                 pr_err("Unable to allocate bootmem pages "
632                                         "for %s\n", gp_resources[i].name);
633
634                         else {
635                                 gp_resources[i].start =
636                                         phys_to_dma(virt_to_phys(mem));
637                                 gp_resources[i].end =
638                                         gp_resources[i].start + size - 1;
639                                 total += size;
640                                 pr_info("allocate resource %s at %08x "
641                                                 "(%u bytes)\n",
642                                         gp_resources[i].name,
643                                         gp_resources[i].start, size);
644                         }
645                 }
646         }
647
648         pr_info("Total Platform driver memory allocation: 0x%08x\n", total);
649
650         /* indicate resources that are platform I/O related */
651         for (i = 0; gp_resources[i].flags != 0; i++) {
652                 if ((gp_resources[i].start != 0) &&
653                         ((gp_resources[i].flags & IORESOURCE_IO) != 0)) {
654                         pr_info("reserved platform resource %s at %08x\n",
655                                 gp_resources[i].name, gp_resources[i].start);
656                 }
657         }
658 }
659
660 /*
661  *
662  * PERSISTENT MEMORY (PMEM) CONFIGURATION
663  *
664  */
665 static unsigned long pmemaddr __initdata;
666
667 static int __init early_param_pmemaddr(char *p)
668 {
669         pmemaddr = (unsigned long)simple_strtoul(p, NULL, 0);
670         return 0;
671 }
672 early_param("pmemaddr", early_param_pmemaddr);
673
674 static long pmemlen __initdata;
675
676 static int __init early_param_pmemlen(char *p)
677 {
678 /* TODO: we can use this code when and if the bootloader ever changes this */
679 #if 0
680         pmemlen = (unsigned long)simple_strtoul(p, NULL, 0);
681 #else
682         pmemlen = 0x20000;
683 #endif
684         return 0;
685 }
686 early_param("pmemlen", early_param_pmemlen);
687
688 /*
689  * Set up persistent memory. If we were given values, we patch the array of
690  * resources. Otherwise, persistent memory may be allocated anywhere at all.
691  */
692 static void __init pmem_setup_resource(void)
693 {
694         struct resource *resource;
695         resource = asic_resource_get("DiagPersistentMemory");
696
697         if (resource && pmemaddr && pmemlen) {
698                 /* The address provided by bootloader is in kseg0. Convert to
699                  * a bus address. */
700                 resource->start = phys_to_dma(pmemaddr - 0x80000000);
701                 resource->end = resource->start + pmemlen - 1;
702
703                 pr_info("persistent memory: start=0x%x  end=0x%x\n",
704                         resource->start, resource->end);
705         }
706 }
707
708 /*
709  *
710  * RESOURCE ACCESS FUNCTIONS
711  *
712  */
713
714 /**
715  * asic_resource_get - retrieves parameters for a platform resource.
716  * @name:       string to match resource
717  *
718  * Returns a pointer to a struct resource corresponding to the given name.
719  *
720  * CANNOT BE NAMED platform_resource_get, which would be the obvious choice,
721  * as this function name is already declared
722  */
723 struct resource *asic_resource_get(const char *name)
724 {
725         int i;
726
727         for (i = 0; gp_resources[i].flags != 0; i++) {
728                 if (strcmp(gp_resources[i].name, name) == 0)
729                         return &gp_resources[i];
730         }
731
732         return NULL;
733 }
734 EXPORT_SYMBOL(asic_resource_get);
735
736 /**
737  * platform_release_memory - release pre-allocated memory
738  * @ptr:        pointer to memory to release
739  * @size:       size of resource
740  *
741  * This must only be called for memory allocated or reserved via the boot
742  * memory allocator.
743  */
744 void platform_release_memory(void *ptr, int size)
745 {
746         unsigned long addr;
747         unsigned long end;
748
749         addr = ((unsigned long)ptr + (PAGE_SIZE - 1)) & PAGE_MASK;
750         end = ((unsigned long)ptr + size) & PAGE_MASK;
751
752         for (; addr < end; addr += PAGE_SIZE) {
753                 ClearPageReserved(virt_to_page(__va(addr)));
754                 init_page_count(virt_to_page(__va(addr)));
755                 free_page((unsigned long)__va(addr));
756         }
757 }
758 EXPORT_SYMBOL(platform_release_memory);
759
760 /*
761  *
762  * FEATURE AVAILABILITY FUNCTIONS
763  *
764  */
765 int platform_supports_dvr(void)
766 {
767         return (platform_features & DVR_CAPABLE) != 0;
768 }
769
770 int platform_supports_ffs(void)
771 {
772         return (platform_features & FFS_CAPABLE) != 0;
773 }
774
775 int platform_supports_pcie(void)
776 {
777         return (platform_features & PCIE_CAPABLE) != 0;
778 }
779
780 int platform_supports_display(void)
781 {
782         return (platform_features & DISPLAY_CAPABLE) != 0;
783 }