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