blob: b2590409f25efb1911dc8e87a4d88c2dc0b3d719 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
44extern int m68k_realnum_memory;
45extern struct mem_info m68k_memory[NUM_MEMINFO];
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#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
58static u_long *z2ram_map = NULL;
59static u_long z2ram_size = 0;
60static int z2_count = 0;
61static int chip_count = 0;
62static int list_count = 0;
63static int current_device = -1;
64
65static DEFINE_SPINLOCK(z2ram_lock);
66
67static struct block_device_operations z2_fops;
68static struct gendisk *z2ram_gendisk;
69
Jens Axboe165125e2007-07-24 09:28:11 +020070static void do_z2_request(struct request_queue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071{
72 struct request *req;
Tejun Heofb3ac7f6b2009-05-08 11:54:13 +090073
Tejun Heo9934c8c2009-05-08 11:54:16 +090074 req = blk_fetch_request(q);
Tejun Heofb3ac7f6b2009-05-08 11:54:13 +090075 while (req) {
Tejun Heo83096eb2009-05-07 22:24:39 +090076 unsigned long start = blk_rq_pos(req) << 9;
Tejun Heo1011c1b2009-05-07 22:24:45 +090077 unsigned long len = blk_rq_cur_bytes(req);
Tejun Heofb3ac7f6b2009-05-08 11:54:13 +090078 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80 if (start + len > z2ram_size) {
81 printk( KERN_ERR DEVICE_NAME ": bad access: block=%lu, count=%u\n",
Tejun Heo83096eb2009-05-07 22:24:39 +090082 blk_rq_pos(req), blk_rq_cur_sectors(req));
Tejun Heofb3ac7f6b2009-05-08 11:54:13 +090083 err = -EIO;
84 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 }
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 }
Tejun Heofb3ac7f6b2009-05-08 11:54:13 +090099 done:
Tejun Heo9934c8c2009-05-08 11:54:16 +0900100 if (!__blk_end_request_cur(req, err))
101 req = blk_fetch_request(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 }
103}
104
105static void
106get_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
124static void
125get_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
Al Viroab746cb2008-03-02 10:24:45 -0500145static int z2_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
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
Al Viroab746cb2008-03-02 10:24:45 -0500154 device = MINOR(bdev->bd_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
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
299err_out_kfree:
Jesper Juhlf91012102005-09-10 00:26:54 -0700300 kfree(z2ram_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301err_out:
302 return rc;
303}
304
305static int
Al Viroab746cb2008-03-02 10:24:45 -0500306z2_release(struct gendisk *disk, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{
308 if ( current_device == -1 )
309 return 0;
310
311 /*
312 * FIXME: unmap memory
313 */
314
315 return 0;
316}
317
318static struct block_device_operations z2_fops =
319{
320 .owner = THIS_MODULE,
Al Viroab746cb2008-03-02 10:24:45 -0500321 .open = z2_open,
322 .release = z2_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323};
324
325static struct kobject *z2_find(dev_t dev, int *part, void *data)
326{
327 *part = 0;
328 return get_disk(z2ram_gendisk);
329}
330
331static struct request_queue *z2_queue;
332
Al Virof39d88a2006-10-11 17:28:47 +0100333static int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334z2_init(void)
335{
336 int ret;
337
338 if (!MACH_IS_AMIGA)
Geert Uytterhoevenfd5b4622008-05-18 20:47:18 +0200339 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
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");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
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
366out_queue:
367 put_disk(z2ram_gendisk);
368out_disk:
369 unregister_blkdev(Z2RAM_MAJOR, DEVICE_NAME);
370err:
371 return ret;
372}
373
Al Virof39d88a2006-10-11 17:28:47 +0100374static void __exit z2_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375{
376 int i, j;
Zhaoleic9d4bc22009-07-14 17:59:05 +0800377 blk_unregister_region(MKDEV(Z2RAM_MAJOR, 0), Z2MINOR_COUNT);
Akinobu Mita00d59402007-07-17 04:03:46 -0700378 unregister_blkdev(Z2RAM_MAJOR, DEVICE_NAME);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 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}
Al Virof39d88a2006-10-11 17:28:47 +0100408
409module_init(z2_init);
410module_exit(z2_exit);
411MODULE_LICENSE("GPL");