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