z2ram.c 8.9 KB

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