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