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 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 70 static void do_z2_request(struct request_queue *q) 71 { 72 struct request *req; 73 74 req = blk_fetch_request(q); 75 while (req) { 76 unsigned long start = blk_rq_pos(req) << 9; 77 unsigned long len = blk_rq_cur_bytes(req); 78 int err = 0; 79 80 if (start + len > z2ram_size) { 81 printk( KERN_ERR DEVICE_NAME ": bad access: block=%lu, count=%u\n", 82 blk_rq_pos(req), blk_rq_cur_sectors(req)); 83 err = -EIO; 84 goto done; 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 done: 100 if (!__blk_end_request_cur(req, err)) 101 req = blk_fetch_request(q); 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 145 static int z2_open(struct block_device *bdev, fmode_t mode) 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 154 device = MINOR(bdev->bd_dev); 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: 300 kfree(z2ram_map); 301 err_out: 302 return rc; 303 } 304 305 static int 306 z2_release(struct gendisk *disk, fmode_t mode) 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, 321 .open = z2_open, 322 .release = z2_release, 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 333 static int __init 334 z2_init(void) 335 { 336 int ret; 337 338 if (!MACH_IS_AMIGA) 339 return -ENODEV; 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"); 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 static void __exit z2_exit(void) 375 { 376 int i, j; 377 blk_unregister_region(MKDEV(Z2RAM_MAJOR, 0), Z2MINOR_COUNT); 378 unregister_blkdev(Z2RAM_MAJOR, DEVICE_NAME); 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 } 408 409 module_init(z2_init); 410 module_exit(z2_exit); 411 MODULE_LICENSE("GPL"); 412