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
47 #define TRUE (1)
48 #define FALSE (0)
49
50 #define Z2MINOR_COMBINED (0)
51 #define Z2MINOR_Z2ONLY (1)
52 #define Z2MINOR_CHIPONLY (2)
53 #define Z2MINOR_MEMLIST1 (4)
54 #define Z2MINOR_MEMLIST2 (5)
55 #define Z2MINOR_MEMLIST3 (6)
56 #define Z2MINOR_MEMLIST4 (7)
57 #define Z2MINOR_COUNT (8) /* Move this down when adding a new minor */
58
59 #define Z2RAM_CHUNK1024 ( Z2RAM_CHUNKSIZE >> 10 )
60
61 static u_long *z2ram_map = NULL;
62 static u_long z2ram_size = 0;
63 static int z2_count = 0;
64 static int chip_count = 0;
65 static int list_count = 0;
66 static int current_device = -1;
67
68 static DEFINE_SPINLOCK(z2ram_lock);
69
70 static struct block_device_operations z2_fops;
71 static struct gendisk *z2ram_gendisk;
72
73 static void do_z2_request(request_queue_t *q)
74 {
75 struct request *req;
76 while ((req = elv_next_request(q)) != NULL) {
77 unsigned long start = req->sector << 9;
78 unsigned long len = req->current_nr_sectors << 9;
79
80 if (start + len > z2ram_size) {
81 printk( KERN_ERR DEVICE_NAME ": bad access: block=%lu, count=%u\n",
82 req->sector, req->current_nr_sectors);
83 end_request(req, 0);
84 continue;
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 }
99 end_request(req, 1);
100 }
101 }
102
103 static void
104 get_z2ram( void )
105 {
106 int i;
107
108 for ( i = 0; i < Z2RAM_SIZE / Z2RAM_CHUNKSIZE; i++ )
109 {
110 if ( test_bit( i, zorro_unused_z2ram ) )
111 {
112 z2_count++;
113 z2ram_map[ z2ram_size++ ] =
114 ZTWO_VADDR( Z2RAM_START ) + ( i << Z2RAM_CHUNKSHIFT );
115 clear_bit( i, zorro_unused_z2ram );
116 }
117 }
118
119 return;
120 }
121
122 static void
123 get_chipram( void )
124 {
125
126 while ( amiga_chip_avail() > ( Z2RAM_CHUNKSIZE * 4 ) )
127 {
128 chip_count++;
129 z2ram_map[ z2ram_size ] =
130 (u_long)amiga_chip_alloc( Z2RAM_CHUNKSIZE, "z2ram" );
131
132 if ( z2ram_map[ z2ram_size ] == 0 )
133 {
134 break;
135 }
136
137 z2ram_size++;
138 }
139
140 return;
141 }
142
143 static int
144 z2_open( struct inode *inode, struct file *filp )
145 {
146 int device;
147 int max_z2_map = ( Z2RAM_SIZE / Z2RAM_CHUNKSIZE ) *
148 sizeof( z2ram_map[0] );
149 int max_chip_map = ( amiga_chip_size / Z2RAM_CHUNKSIZE ) *
150 sizeof( z2ram_map[0] );
151 int rc = -ENOMEM;
152
153 device = iminor(inode);
154
155 if ( current_device != -1 && current_device != device )
156 {
157 rc = -EBUSY;
158 goto err_out;
159 }
160
161 if ( current_device == -1 )
162 {
163 z2_count = 0;
164 chip_count = 0;
165 list_count = 0;
166 z2ram_size = 0;
167
168 /* Use a specific list entry. */
169 if (device >= Z2MINOR_MEMLIST1 && device <= Z2MINOR_MEMLIST4) {
170 int index = device - Z2MINOR_MEMLIST1 + 1;
171 unsigned long size, paddr, vaddr;
172
173 if (index >= m68k_realnum_memory) {
174 printk( KERN_ERR DEVICE_NAME
175 ": no such entry in z2ram_map\n" );
176 goto err_out;
177 }
178
179 paddr = m68k_memory[index].addr;
180 size = m68k_memory[index].size & ~(Z2RAM_CHUNKSIZE-1);
181
182 #ifdef __powerpc__
183 /* FIXME: ioremap doesn't build correct memory tables. */
184 {
185 vfree(vmalloc (size));
186 }
187
188 vaddr = (unsigned long) __ioremap (paddr, size,
189 _PAGE_WRITETHRU);
190
191 #else
192 vaddr = (unsigned long)z_remap_nocache_nonser(paddr, size);
193 #endif
194 z2ram_map =
195 kmalloc((size/Z2RAM_CHUNKSIZE)*sizeof(z2ram_map[0]),
196 GFP_KERNEL);
197 if ( z2ram_map == NULL )
198 {
199 printk( KERN_ERR DEVICE_NAME
200 ": cannot get mem for z2ram_map\n" );
201 goto err_out;
202 }
203
204 while (size) {
205 z2ram_map[ z2ram_size++ ] = vaddr;
206 size -= Z2RAM_CHUNKSIZE;
207 vaddr += Z2RAM_CHUNKSIZE;
208 list_count++;
209 }
210
211 if ( z2ram_size != 0 )
212 printk( KERN_INFO DEVICE_NAME
213 ": using %iK List Entry %d Memory\n",
214 list_count * Z2RAM_CHUNK1024, index );
215 } else
216
217 switch ( device )
218 {
219 case Z2MINOR_COMBINED:
220
221 z2ram_map = kmalloc( max_z2_map + max_chip_map, GFP_KERNEL );
222 if ( z2ram_map == NULL )
223 {
224 printk( KERN_ERR DEVICE_NAME
225 ": cannot get mem for z2ram_map\n" );
226 goto err_out;
227 }
228
229 get_z2ram();
230 get_chipram();
231
232 if ( z2ram_size != 0 )
233 printk( KERN_INFO DEVICE_NAME
234 ": using %iK Zorro II RAM and %iK Chip RAM (Total %dK)\n",
235 z2_count * Z2RAM_CHUNK1024,
236 chip_count * Z2RAM_CHUNK1024,
237 ( z2_count + chip_count ) * Z2RAM_CHUNK1024 );
238
239 break;
240
241 case Z2MINOR_Z2ONLY:
242 z2ram_map = kmalloc( max_z2_map, GFP_KERNEL );
243 if ( z2ram_map == NULL )
244 {
245 printk( KERN_ERR DEVICE_NAME
246 ": cannot get mem for z2ram_map\n" );
247 goto err_out;
248 }
249
250 get_z2ram();
251
252 if ( z2ram_size != 0 )
253 printk( KERN_INFO DEVICE_NAME
254 ": using %iK of Zorro II RAM\n",
255 z2_count * Z2RAM_CHUNK1024 );
256
257 break;
258
259 case Z2MINOR_CHIPONLY:
260 z2ram_map = kmalloc( max_chip_map, GFP_KERNEL );
261 if ( z2ram_map == NULL )
262 {
263 printk( KERN_ERR DEVICE_NAME
264 ": cannot get mem for z2ram_map\n" );
265 goto err_out;
266 }
267
268 get_chipram();
269
270 if ( z2ram_size != 0 )
271 printk( KERN_INFO DEVICE_NAME
272 ": using %iK Chip RAM\n",
273 chip_count * Z2RAM_CHUNK1024 );
274
275 break;
276
277 default:
278 rc = -ENODEV;
279 goto err_out;
280
281 break;
282 }
283
284 if ( z2ram_size == 0 )
285 {
286 printk( KERN_NOTICE DEVICE_NAME
287 ": no unused ZII/Chip RAM found\n" );
288 goto err_out_kfree;
289 }
290
291 current_device = device;
292 z2ram_size <<= Z2RAM_CHUNKSHIFT;
293 set_capacity(z2ram_gendisk, z2ram_size >> 9);
294 }
295
296 return 0;
297
298 err_out_kfree:
299 kfree( z2ram_map );
300 err_out:
301 return rc;
302 }
303
304 static int
305 z2_release( struct inode *inode, struct file *filp )
306 {
307 if ( current_device == -1 )
308 return 0;
309
310 /*
311 * FIXME: unmap memory
312 */
313
314 return 0;
315 }
316
317 static struct block_device_operations z2_fops =
318 {
319 .owner = THIS_MODULE,
320 .open = z2_open,
321 .release = z2_release,
322 };
323
324 static struct kobject *z2_find(dev_t dev, int *part, void *data)
325 {
326 *part = 0;
327 return get_disk(z2ram_gendisk);
328 }
329
330 static struct request_queue *z2_queue;
331
332 int __init
333 z2_init(void)
334 {
335 int ret;
336
337 if (!MACH_IS_AMIGA)
338 return -ENXIO;
339
340 ret = -EBUSY;
341 if (register_blkdev(Z2RAM_MAJOR, DEVICE_NAME))
342 goto err;
343
344 ret = -ENOMEM;
345 z2ram_gendisk = alloc_disk(1);
346 if (!z2ram_gendisk)
347 goto out_disk;
348
349 z2_queue = blk_init_queue(do_z2_request, &z2ram_lock);
350 if (!z2_queue)
351 goto out_queue;
352
353 z2ram_gendisk->major = Z2RAM_MAJOR;
354 z2ram_gendisk->first_minor = 0;
355 z2ram_gendisk->fops = &z2_fops;
356 sprintf(z2ram_gendisk->disk_name, "z2ram");
357 strcpy(z2ram_gendisk->devfs_name, z2ram_gendisk->disk_name);
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
374 #if defined(MODULE)
375
376 MODULE_LICENSE("GPL");
377
378 int
379 init_module( void )
380 {
381 int error;
382
383 error = z2_init();
384 if ( error == 0 )
385 {
386 printk( KERN_INFO DEVICE_NAME ": loaded as module\n" );
387 }
388
389 return error;
390 }
391
392 void
393 cleanup_module( void )
394 {
395 int i, j;
396 blk_unregister_region(MKDEV(Z2RAM_MAJOR, 0), 256);
397 if ( unregister_blkdev( Z2RAM_MAJOR, DEVICE_NAME ) != 0 )
398 printk( KERN_ERR DEVICE_NAME ": unregister of device failed\n");
399
400 del_gendisk(z2ram_gendisk);
401 put_disk(z2ram_gendisk);
402 blk_cleanup_queue(z2_queue);
403
404 if ( current_device != -1 )
405 {
406 i = 0;
407
408 for ( j = 0 ; j < z2_count; j++ )
409 {
410 set_bit( i++, zorro_unused_z2ram );
411 }
412
413 for ( j = 0 ; j < chip_count; j++ )
414 {
415 if ( z2ram_map[ i ] )
416 {
417 amiga_chip_free( (void *) z2ram_map[ i++ ] );
418 }
419 }
420
421 if ( z2ram_map != NULL )
422 {
423 kfree( z2ram_map );
424 }
425 }
426
427 return;
428 }
429 #endif
430
|
This page was automatically generated by the
LXR engine.
|