2 * SPU local store allocation routines
4 * Copyright 2007 Benjamin Herrenschmidt, IBM Corp.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2, or (at your option)
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #include <linux/kernel.h>
25 #include <linux/slab.h>
26 #include <linux/vmalloc.h>
29 #include <asm/spu_csa.h>
34 static int spu_alloc_lscsa_std(struct spu_state *csa)
36 struct spu_lscsa *lscsa;
39 lscsa = vmalloc(sizeof(struct spu_lscsa));
42 memset(lscsa, 0, sizeof(struct spu_lscsa));
45 /* Set LS pages reserved to allow for user-space mapping. */
46 for (p = lscsa->ls; p < lscsa->ls + LS_SIZE; p += PAGE_SIZE)
47 SetPageReserved(vmalloc_to_page(p));
52 static void spu_free_lscsa_std(struct spu_state *csa)
54 /* Clear reserved bit before vfree. */
57 if (csa->lscsa == NULL)
60 for (p = csa->lscsa->ls; p < csa->lscsa->ls + LS_SIZE; p += PAGE_SIZE)
61 ClearPageReserved(vmalloc_to_page(p));
66 #ifdef CONFIG_SPU_FS_64K_LS
68 #define SPU_64K_PAGE_SHIFT 16
69 #define SPU_64K_PAGE_ORDER (SPU_64K_PAGE_SHIFT - PAGE_SHIFT)
70 #define SPU_64K_PAGE_COUNT (1ul << SPU_64K_PAGE_ORDER)
72 int spu_alloc_lscsa(struct spu_state *csa)
74 struct page **pgarray;
78 /* Check availability of 64K pages */
79 if (!spu_64k_pages_available())
82 csa->use_big_pages = 1;
84 pr_debug("spu_alloc_lscsa(csa=0x%p), trying to allocate 64K pages\n",
87 /* First try to allocate our 64K pages. We need 5 of them
88 * with the current implementation. In the future, we should try
89 * to separate the lscsa with the actual local store image, thus
90 * allowing us to require only 4 64K pages per context
92 for (i = 0; i < SPU_LSCSA_NUM_BIG_PAGES; i++) {
93 /* XXX This is likely to fail, we should use a special pool
94 * similiar to what hugetlbfs does.
96 csa->lscsa_pages[i] = alloc_pages(GFP_KERNEL,
98 if (csa->lscsa_pages[i] == NULL)
102 pr_debug(" success ! creating vmap...\n");
104 /* Now we need to create a vmalloc mapping of these for the kernel
105 * and SPU context switch code to use. Currently, we stick to a
106 * normal kernel vmalloc mapping, which in our case will be 4K
108 n_4k = SPU_64K_PAGE_COUNT * SPU_LSCSA_NUM_BIG_PAGES;
109 pgarray = kmalloc(sizeof(struct page *) * n_4k, GFP_KERNEL);
112 for (i = 0; i < SPU_LSCSA_NUM_BIG_PAGES; i++)
113 for (j = 0; j < SPU_64K_PAGE_COUNT; j++)
114 /* We assume all the struct page's are contiguous
115 * which should be hopefully the case for an order 4
118 pgarray[i * SPU_64K_PAGE_COUNT + j] =
119 csa->lscsa_pages[i] + j;
120 csa->lscsa = vmap(pgarray, n_4k, VM_USERMAP, PAGE_KERNEL);
122 if (csa->lscsa == NULL)
125 memset(csa->lscsa, 0, sizeof(struct spu_lscsa));
127 /* Set LS pages reserved to allow for user-space mapping.
129 * XXX isn't that a bit obsolete ? I think we should just
130 * make sure the page count is high enough. Anyway, won't harm
133 for (p = csa->lscsa->ls; p < csa->lscsa->ls + LS_SIZE; p += PAGE_SIZE)
134 SetPageReserved(vmalloc_to_page(p));
136 pr_debug(" all good !\n");
140 pr_debug("spufs: failed to allocate lscsa 64K pages, falling back\n");
142 return spu_alloc_lscsa_std(csa);
145 void spu_free_lscsa(struct spu_state *csa)
150 if (!csa->use_big_pages) {
151 spu_free_lscsa_std(csa);
154 csa->use_big_pages = 0;
156 if (csa->lscsa == NULL)
159 for (p = csa->lscsa->ls; p < csa->lscsa->ls + LS_SIZE; p += PAGE_SIZE)
160 ClearPageReserved(vmalloc_to_page(p));
167 for (i = 0; i < SPU_LSCSA_NUM_BIG_PAGES; i++)
168 if (csa->lscsa_pages[i])
169 __free_pages(csa->lscsa_pages[i], SPU_64K_PAGE_ORDER);
172 #else /* CONFIG_SPU_FS_64K_LS */
174 int spu_alloc_lscsa(struct spu_state *csa)
176 return spu_alloc_lscsa_std(csa);
179 void spu_free_lscsa(struct spu_state *csa)
181 spu_free_lscsa_std(csa);
184 #endif /* !defined(CONFIG_SPU_FS_64K_LS) */