z2ram.c 9.5 KB

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