Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | ** z2ram - Amiga pseudo-driver to access 16bit-RAM in ZorroII space | |
3 | ** as a block device, to be used as a RAM disk or swap space | |
4 | ** | |
5 | ** Copyright (C) 1994 by Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de) | |
6 | ** | |
7 | ** ++Geert: support for zorro_unused_z2ram, better range checking | |
8 | ** ++roman: translate accesses via an array | |
9 | ** ++Milan: support for ChipRAM usage | |
10 | ** ++yambo: converted to 2.0 kernel | |
11 | ** ++yambo: modularized and support added for 3 minor devices including: | |
12 | ** MAJOR MINOR DESCRIPTION | |
13 | ** ----- ----- ---------------------------------------------- | |
14 | ** 37 0 Use Zorro II and Chip ram | |
15 | ** 37 1 Use only Zorro II ram | |
16 | ** 37 2 Use only Chip ram | |
17 | ** 37 4-7 Use memory list entry 1-4 (first is 0) | |
18 | ** ++jskov: support for 1-4th memory list entry. | |
19 | ** | |
20 | ** Permission to use, copy, modify, and distribute this software and its | |
21 | ** documentation for any purpose and without fee is hereby granted, provided | |
22 | ** that the above copyright notice appear in all copies and that both that | |
23 | ** copyright notice and this permission notice appear in supporting | |
24 | ** documentation. This software is provided "as is" without express or | |
25 | ** implied warranty. | |
26 | */ | |
27 | ||
28 | #define DEVICE_NAME "Z2RAM" | |
29 | ||
30 | #include <linux/major.h> | |
31 | #include <linux/vmalloc.h> | |
32 | #include <linux/init.h> | |
33 | #include <linux/module.h> | |
34 | #include <linux/blkdev.h> | |
35 | #include <linux/bitops.h> | |
2a48fc0a | 36 | #include <linux/mutex.h> |
5a0e3ad6 | 37 | #include <linux/slab.h> |
1da177e4 LT |
38 | |
39 | #include <asm/setup.h> | |
40 | #include <asm/amigahw.h> | |
41 | #include <asm/pgtable.h> | |
42 | ||
43 | #include <linux/zorro.h> | |
44 | ||
45 | ||
1da177e4 LT |
46 | #define Z2MINOR_COMBINED (0) |
47 | #define Z2MINOR_Z2ONLY (1) | |
48 | #define Z2MINOR_CHIPONLY (2) | |
49 | #define Z2MINOR_MEMLIST1 (4) | |
50 | #define Z2MINOR_MEMLIST2 (5) | |
51 | #define Z2MINOR_MEMLIST3 (6) | |
52 | #define Z2MINOR_MEMLIST4 (7) | |
53 | #define Z2MINOR_COUNT (8) /* Move this down when adding a new minor */ | |
54 | ||
55 | #define Z2RAM_CHUNK1024 ( Z2RAM_CHUNKSIZE >> 10 ) | |
56 | ||
2a48fc0a | 57 | static DEFINE_MUTEX(z2ram_mutex); |
1da177e4 LT |
58 | static u_long *z2ram_map = NULL; |
59 | static u_long z2ram_size = 0; | |
60 | static int z2_count = 0; | |
61 | static int chip_count = 0; | |
62 | static int list_count = 0; | |
63 | static int current_device = -1; | |
64 | ||
65 | static DEFINE_SPINLOCK(z2ram_lock); | |
66 | ||
1da177e4 LT |
67 | static struct gendisk *z2ram_gendisk; |
68 | ||
165125e1 | 69 | static void do_z2_request(struct request_queue *q) |
1da177e4 LT |
70 | { |
71 | struct request *req; | |
fb3ac7f6 | 72 | |
9934c8c0 | 73 | req = blk_fetch_request(q); |
fb3ac7f6 | 74 | while (req) { |
83096ebf | 75 | unsigned long start = blk_rq_pos(req) << 9; |
1011c1b9 | 76 | unsigned long len = blk_rq_cur_bytes(req); |
fb3ac7f6 | 77 | int err = 0; |
1da177e4 LT |
78 | |
79 | if (start + len > z2ram_size) { | |
e1fbd921 GU |
80 | pr_err(DEVICE_NAME ": bad access: block=%llu, " |
81 | "count=%u\n", | |
82 | (unsigned long long)blk_rq_pos(req), | |
83 | blk_rq_cur_sectors(req)); | |
fb3ac7f6 TH |
84 | err = -EIO; |
85 | goto done; | |
1da177e4 LT |
86 | } |
87 | while (len) { | |
88 | unsigned long addr = start & Z2RAM_CHUNKMASK; | |
89 | unsigned long size = Z2RAM_CHUNKSIZE - addr; | |
90 | if (len < size) | |
91 | size = len; | |
92 | addr += z2ram_map[ start >> Z2RAM_CHUNKSHIFT ]; | |
93 | if (rq_data_dir(req) == READ) | |
94 | memcpy(req->buffer, (char *)addr, size); | |
95 | else | |
96 | memcpy((char *)addr, req->buffer, size); | |
97 | start += size; | |
98 | len -= size; | |
99 | } | |
fb3ac7f6 | 100 | done: |
9934c8c0 TH |
101 | if (!__blk_end_request_cur(req, err)) |
102 | req = blk_fetch_request(q); | |
1da177e4 LT |
103 | } |
104 | } | |
105 | ||
106 | static void | |
107 | get_z2ram( void ) | |
108 | { | |
109 | int i; | |
110 | ||
111 | for ( i = 0; i < Z2RAM_SIZE / Z2RAM_CHUNKSIZE; i++ ) | |
112 | { | |
113 | if ( test_bit( i, zorro_unused_z2ram ) ) | |
114 | { | |
115 | z2_count++; | |
6112ea08 GU |
116 | z2ram_map[z2ram_size++] = (unsigned long)ZTWO_VADDR(Z2RAM_START) + |
117 | (i << Z2RAM_CHUNKSHIFT); | |
1da177e4 LT |
118 | clear_bit( i, zorro_unused_z2ram ); |
119 | } | |
120 | } | |
121 | ||
122 | return; | |
123 | } | |
124 | ||
125 | static void | |
126 | get_chipram( void ) | |
127 | { | |
128 | ||
129 | while ( amiga_chip_avail() > ( Z2RAM_CHUNKSIZE * 4 ) ) | |
130 | { | |
131 | chip_count++; | |
132 | z2ram_map[ z2ram_size ] = | |
133 | (u_long)amiga_chip_alloc( Z2RAM_CHUNKSIZE, "z2ram" ); | |
134 | ||
135 | if ( z2ram_map[ z2ram_size ] == 0 ) | |
136 | { | |
137 | break; | |
138 | } | |
139 | ||
140 | z2ram_size++; | |
141 | } | |
142 | ||
143 | return; | |
144 | } | |
145 | ||
ab746cb9 | 146 | static int z2_open(struct block_device *bdev, fmode_t mode) |
1da177e4 LT |
147 | { |
148 | int device; | |
149 | int max_z2_map = ( Z2RAM_SIZE / Z2RAM_CHUNKSIZE ) * | |
150 | sizeof( z2ram_map[0] ); | |
151 | int max_chip_map = ( amiga_chip_size / Z2RAM_CHUNKSIZE ) * | |
152 | sizeof( z2ram_map[0] ); | |
153 | int rc = -ENOMEM; | |
154 | ||
ab746cb9 | 155 | device = MINOR(bdev->bd_dev); |
1da177e4 | 156 | |
2a48fc0a | 157 | mutex_lock(&z2ram_mutex); |
1da177e4 LT |
158 | if ( current_device != -1 && current_device != device ) |
159 | { | |
160 | rc = -EBUSY; | |
161 | goto err_out; | |
162 | } | |
163 | ||
164 | if ( current_device == -1 ) | |
165 | { | |
166 | z2_count = 0; | |
167 | chip_count = 0; | |
168 | list_count = 0; | |
169 | z2ram_size = 0; | |
170 | ||
171 | /* Use a specific list entry. */ | |
172 | if (device >= Z2MINOR_MEMLIST1 && device <= Z2MINOR_MEMLIST4) { | |
173 | int index = device - Z2MINOR_MEMLIST1 + 1; | |
174 | unsigned long size, paddr, vaddr; | |
175 | ||
176 | if (index >= m68k_realnum_memory) { | |
177 | printk( KERN_ERR DEVICE_NAME | |
178 | ": no such entry in z2ram_map\n" ); | |
179 | goto err_out; | |
180 | } | |
181 | ||
182 | paddr = m68k_memory[index].addr; | |
183 | size = m68k_memory[index].size & ~(Z2RAM_CHUNKSIZE-1); | |
184 | ||
185 | #ifdef __powerpc__ | |
186 | /* FIXME: ioremap doesn't build correct memory tables. */ | |
187 | { | |
188 | vfree(vmalloc (size)); | |
189 | } | |
190 | ||
191 | vaddr = (unsigned long) __ioremap (paddr, size, | |
192 | _PAGE_WRITETHRU); | |
193 | ||
194 | #else | |
195 | vaddr = (unsigned long)z_remap_nocache_nonser(paddr, size); | |
196 | #endif | |
197 | z2ram_map = | |
198 | kmalloc((size/Z2RAM_CHUNKSIZE)*sizeof(z2ram_map[0]), | |
199 | GFP_KERNEL); | |
200 | if ( z2ram_map == NULL ) | |
201 | { | |
202 | printk( KERN_ERR DEVICE_NAME | |
203 | ": cannot get mem for z2ram_map\n" ); | |
204 | goto err_out; | |
205 | } | |
206 | ||
207 | while (size) { | |
208 | z2ram_map[ z2ram_size++ ] = vaddr; | |
209 | size -= Z2RAM_CHUNKSIZE; | |
210 | vaddr += Z2RAM_CHUNKSIZE; | |
211 | list_count++; | |
212 | } | |
213 | ||
214 | if ( z2ram_size != 0 ) | |
215 | printk( KERN_INFO DEVICE_NAME | |
216 | ": using %iK List Entry %d Memory\n", | |
217 | list_count * Z2RAM_CHUNK1024, index ); | |
218 | } else | |
219 | ||
220 | switch ( device ) | |
221 | { | |
222 | case Z2MINOR_COMBINED: | |
223 | ||
224 | z2ram_map = kmalloc( max_z2_map + max_chip_map, GFP_KERNEL ); | |
225 | if ( z2ram_map == NULL ) | |
226 | { | |
227 | printk( KERN_ERR DEVICE_NAME | |
228 | ": cannot get mem for z2ram_map\n" ); | |
229 | goto err_out; | |
230 | } | |
231 | ||
232 | get_z2ram(); | |
233 | get_chipram(); | |
234 | ||
235 | if ( z2ram_size != 0 ) | |
236 | printk( KERN_INFO DEVICE_NAME | |
237 | ": using %iK Zorro II RAM and %iK Chip RAM (Total %dK)\n", | |
238 | z2_count * Z2RAM_CHUNK1024, | |
239 | chip_count * Z2RAM_CHUNK1024, | |
240 | ( z2_count + chip_count ) * Z2RAM_CHUNK1024 ); | |
241 | ||
242 | break; | |
243 | ||
244 | case Z2MINOR_Z2ONLY: | |
245 | z2ram_map = kmalloc( max_z2_map, GFP_KERNEL ); | |
246 | if ( z2ram_map == NULL ) | |
247 | { | |
248 | printk( KERN_ERR DEVICE_NAME | |
249 | ": cannot get mem for z2ram_map\n" ); | |
250 | goto err_out; | |
251 | } | |
252 | ||
253 | get_z2ram(); | |
254 | ||
255 | if ( z2ram_size != 0 ) | |
256 | printk( KERN_INFO DEVICE_NAME | |
257 | ": using %iK of Zorro II RAM\n", | |
258 | z2_count * Z2RAM_CHUNK1024 ); | |
259 | ||
260 | break; | |
261 | ||
262 | case Z2MINOR_CHIPONLY: | |
263 | z2ram_map = kmalloc( max_chip_map, GFP_KERNEL ); | |
264 | if ( z2ram_map == NULL ) | |
265 | { | |
266 | printk( KERN_ERR DEVICE_NAME | |
267 | ": cannot get mem for z2ram_map\n" ); | |
268 | goto err_out; | |
269 | } | |
270 | ||
271 | get_chipram(); | |
272 | ||
273 | if ( z2ram_size != 0 ) | |
274 | printk( KERN_INFO DEVICE_NAME | |
275 | ": using %iK Chip RAM\n", | |
276 | chip_count * Z2RAM_CHUNK1024 ); | |
277 | ||
278 | break; | |
279 | ||
280 | default: | |
281 | rc = -ENODEV; | |
282 | goto err_out; | |
283 | ||
284 | break; | |
285 | } | |
286 | ||
287 | if ( z2ram_size == 0 ) | |
288 | { | |
289 | printk( KERN_NOTICE DEVICE_NAME | |
290 | ": no unused ZII/Chip RAM found\n" ); | |
291 | goto err_out_kfree; | |
292 | } | |
293 | ||
294 | current_device = device; | |
295 | z2ram_size <<= Z2RAM_CHUNKSHIFT; | |
296 | set_capacity(z2ram_gendisk, z2ram_size >> 9); | |
297 | } | |
298 | ||
2a48fc0a | 299 | mutex_unlock(&z2ram_mutex); |
1da177e4 LT |
300 | return 0; |
301 | ||
302 | err_out_kfree: | |
f9101210 | 303 | kfree(z2ram_map); |
1da177e4 | 304 | err_out: |
2a48fc0a | 305 | mutex_unlock(&z2ram_mutex); |
1da177e4 LT |
306 | return rc; |
307 | } | |
308 | ||
db2a144b | 309 | static void |
ab746cb9 | 310 | z2_release(struct gendisk *disk, fmode_t mode) |
1da177e4 | 311 | { |
2a48fc0a | 312 | mutex_lock(&z2ram_mutex); |
6e9624b8 | 313 | if ( current_device == -1 ) { |
2a48fc0a | 314 | mutex_unlock(&z2ram_mutex); |
db2a144b | 315 | return; |
6e9624b8 | 316 | } |
2a48fc0a | 317 | mutex_unlock(&z2ram_mutex); |
1da177e4 LT |
318 | /* |
319 | * FIXME: unmap memory | |
320 | */ | |
1da177e4 LT |
321 | } |
322 | ||
83d5cde4 | 323 | static const struct block_device_operations z2_fops = |
1da177e4 LT |
324 | { |
325 | .owner = THIS_MODULE, | |
ab746cb9 AV |
326 | .open = z2_open, |
327 | .release = z2_release, | |
1da177e4 LT |
328 | }; |
329 | ||
330 | static struct kobject *z2_find(dev_t dev, int *part, void *data) | |
331 | { | |
332 | *part = 0; | |
333 | return get_disk(z2ram_gendisk); | |
334 | } | |
335 | ||
336 | static struct request_queue *z2_queue; | |
337 | ||
f39d88ad | 338 | static int __init |
1da177e4 LT |
339 | z2_init(void) |
340 | { | |
341 | int ret; | |
342 | ||
343 | if (!MACH_IS_AMIGA) | |
fd5b462f | 344 | return -ENODEV; |
1da177e4 LT |
345 | |
346 | ret = -EBUSY; | |
347 | if (register_blkdev(Z2RAM_MAJOR, DEVICE_NAME)) | |
348 | goto err; | |
349 | ||
350 | ret = -ENOMEM; | |
351 | z2ram_gendisk = alloc_disk(1); | |
352 | if (!z2ram_gendisk) | |
353 | goto out_disk; | |
354 | ||
355 | z2_queue = blk_init_queue(do_z2_request, &z2ram_lock); | |
356 | if (!z2_queue) | |
357 | goto out_queue; | |
358 | ||
359 | z2ram_gendisk->major = Z2RAM_MAJOR; | |
360 | z2ram_gendisk->first_minor = 0; | |
361 | z2ram_gendisk->fops = &z2_fops; | |
362 | sprintf(z2ram_gendisk->disk_name, "z2ram"); | |
1da177e4 LT |
363 | |
364 | z2ram_gendisk->queue = z2_queue; | |
365 | add_disk(z2ram_gendisk); | |
366 | blk_register_region(MKDEV(Z2RAM_MAJOR, 0), Z2MINOR_COUNT, THIS_MODULE, | |
367 | z2_find, NULL, NULL); | |
368 | ||
369 | return 0; | |
370 | ||
371 | out_queue: | |
372 | put_disk(z2ram_gendisk); | |
373 | out_disk: | |
374 | unregister_blkdev(Z2RAM_MAJOR, DEVICE_NAME); | |
375 | err: | |
376 | return ret; | |
377 | } | |
378 | ||
f39d88ad | 379 | static void __exit z2_exit(void) |
1da177e4 LT |
380 | { |
381 | int i, j; | |
c9d4bc28 | 382 | blk_unregister_region(MKDEV(Z2RAM_MAJOR, 0), Z2MINOR_COUNT); |
00d59405 | 383 | unregister_blkdev(Z2RAM_MAJOR, DEVICE_NAME); |
1da177e4 LT |
384 | del_gendisk(z2ram_gendisk); |
385 | put_disk(z2ram_gendisk); | |
386 | blk_cleanup_queue(z2_queue); | |
387 | ||
388 | if ( current_device != -1 ) | |
389 | { | |
390 | i = 0; | |
391 | ||
392 | for ( j = 0 ; j < z2_count; j++ ) | |
393 | { | |
394 | set_bit( i++, zorro_unused_z2ram ); | |
395 | } | |
396 | ||
397 | for ( j = 0 ; j < chip_count; j++ ) | |
398 | { | |
399 | if ( z2ram_map[ i ] ) | |
400 | { | |
401 | amiga_chip_free( (void *) z2ram_map[ i++ ] ); | |
402 | } | |
403 | } | |
404 | ||
405 | if ( z2ram_map != NULL ) | |
406 | { | |
407 | kfree( z2ram_map ); | |
408 | } | |
409 | } | |
410 | ||
411 | return; | |
412 | } | |
f39d88ad AV |
413 | |
414 | module_init(z2_init); | |
415 | module_exit(z2_exit); | |
416 | MODULE_LICENSE("GPL"); |