blob: c1d20818e6492046082b2616ff74eaaeb5c5ae9c [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>
Jens Axboe8535fd62018-10-15 09:02:45 -060034#include <linux/blk-mq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/bitops.h>
Arnd Bergmann2a48fc02010-06-02 14:28:52 +020036#include <linux/mutex.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090037#include <linux/slab.h>
Mike Rapoport65fddcf2020-06-08 21:32:42 -070038#include <linux/pgtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40#include <asm/setup.h>
41#include <asm/amigahw.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43#include <linux/zorro.h>
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#define Z2MINOR_COMBINED (0)
46#define Z2MINOR_Z2ONLY (1)
47#define Z2MINOR_CHIPONLY (2)
48#define Z2MINOR_MEMLIST1 (4)
49#define Z2MINOR_MEMLIST2 (5)
50#define Z2MINOR_MEMLIST3 (6)
51#define Z2MINOR_MEMLIST4 (7)
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +010052#define Z2MINOR_COUNT (8) /* Move this down when adding a new minor */
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
54#define Z2RAM_CHUNK1024 ( Z2RAM_CHUNKSIZE >> 10 )
55
Arnd Bergmann2a48fc02010-06-02 14:28:52 +020056static DEFINE_MUTEX(z2ram_mutex);
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +010057static u_long *z2ram_map = NULL;
58static u_long z2ram_size = 0;
59static int z2_count = 0;
60static int chip_count = 0;
61static int list_count = 0;
62static int current_device = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64static DEFINE_SPINLOCK(z2ram_lock);
65
Christoph Hellwig76487f02020-10-29 15:58:40 +010066static struct gendisk *z2ram_gendisk[Z2MINOR_COUNT];
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Jens Axboe8535fd62018-10-15 09:02:45 -060068static blk_status_t z2_queue_rq(struct blk_mq_hw_ctx *hctx,
69 const struct blk_mq_queue_data *bd)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
Jens Axboe8535fd62018-10-15 09:02:45 -060071 struct request *req = bd->rq;
72 unsigned long start = blk_rq_pos(req) << 9;
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +010073 unsigned long len = blk_rq_cur_bytes(req);
Tejun Heofb3ac7f6b2009-05-08 11:54:13 +090074
Jens Axboe8535fd62018-10-15 09:02:45 -060075 blk_mq_start_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Jens Axboe8535fd62018-10-15 09:02:45 -060077 if (start + len > z2ram_size) {
78 pr_err(DEVICE_NAME ": bad access: block=%llu, "
79 "count=%u\n",
80 (unsigned long long)blk_rq_pos(req),
81 blk_rq_cur_sectors(req));
82 return BLK_STS_IOERR;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 }
Jens Axboe8535fd62018-10-15 09:02:45 -060084
85 spin_lock_irq(&z2ram_lock);
86
87 while (len) {
88 unsigned long addr = start & Z2RAM_CHUNKMASK;
89 unsigned long size = Z2RAM_CHUNKSIZE - addr;
90 void *buffer = bio_data(req->bio);
91
92 if (len < size)
93 size = len;
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +010094 addr += z2ram_map[start >> Z2RAM_CHUNKSHIFT];
Jens Axboe8535fd62018-10-15 09:02:45 -060095 if (rq_data_dir(req) == READ)
96 memcpy(buffer, (char *)addr, size);
97 else
98 memcpy((char *)addr, buffer, size);
99 start += size;
100 len -= size;
101 }
102
103 spin_unlock_irq(&z2ram_lock);
104 blk_mq_end_request(req, BLK_STS_OK);
105 return BLK_STS_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106}
107
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100108static void get_z2ram(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100110 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100112 for (i = 0; i < Z2RAM_SIZE / Z2RAM_CHUNKSIZE; i++) {
113 if (test_bit(i, zorro_unused_z2ram)) {
114 z2_count++;
115 z2ram_map[z2ram_size++] =
116 (unsigned long)ZTWO_VADDR(Z2RAM_START) +
117 (i << Z2RAM_CHUNKSHIFT);
118 clear_bit(i, zorro_unused_z2ram);
119 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100122 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123}
124
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100125static void get_chipram(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126{
127
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100128 while (amiga_chip_avail() > (Z2RAM_CHUNKSIZE * 4)) {
129 chip_count++;
130 z2ram_map[z2ram_size] =
131 (u_long) amiga_chip_alloc(Z2RAM_CHUNKSIZE, "z2ram");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100133 if (z2ram_map[z2ram_size] == 0) {
134 break;
135 }
136
137 z2ram_size++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 }
139
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100140 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141}
142
Al Viroab746cb2008-03-02 10:24:45 -0500143static int z2_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144{
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100145 int device;
146 int max_z2_map = (Z2RAM_SIZE / Z2RAM_CHUNKSIZE) * sizeof(z2ram_map[0]);
147 int max_chip_map = (amiga_chip_size / Z2RAM_CHUNKSIZE) *
148 sizeof(z2ram_map[0]);
149 int rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100151 device = MINOR(bdev->bd_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100153 mutex_lock(&z2ram_mutex);
154 if (current_device != -1 && current_device != device) {
155 rc = -EBUSY;
156 goto err_out;
157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100159 if (current_device == -1) {
160 z2_count = 0;
161 chip_count = 0;
162 list_count = 0;
163 z2ram_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100165 /* Use a specific list entry. */
166 if (device >= Z2MINOR_MEMLIST1 && device <= Z2MINOR_MEMLIST4) {
167 int index = device - Z2MINOR_MEMLIST1 + 1;
168 unsigned long size, paddr, vaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100170 if (index >= m68k_realnum_memory) {
171 printk(KERN_ERR DEVICE_NAME
172 ": no such entry in z2ram_map\n");
173 goto err_out;
174 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100176 paddr = m68k_memory[index].addr;
177 size = m68k_memory[index].size & ~(Z2RAM_CHUNKSIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
179#ifdef __powerpc__
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100180 /* FIXME: ioremap doesn't build correct memory tables. */
181 {
182 vfree(vmalloc(size));
183 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100185 vaddr = (unsigned long)ioremap_wt(paddr, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
187#else
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100188 vaddr =
189 (unsigned long)z_remap_nocache_nonser(paddr, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190#endif
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100191 z2ram_map =
192 kmalloc_array(size / Z2RAM_CHUNKSIZE,
193 sizeof(z2ram_map[0]), GFP_KERNEL);
194 if (z2ram_map == NULL) {
195 printk(KERN_ERR DEVICE_NAME
196 ": cannot get mem for z2ram_map\n");
197 goto err_out;
198 }
199
200 while (size) {
201 z2ram_map[z2ram_size++] = vaddr;
202 size -= Z2RAM_CHUNKSIZE;
203 vaddr += Z2RAM_CHUNKSIZE;
204 list_count++;
205 }
206
207 if (z2ram_size != 0)
208 printk(KERN_INFO DEVICE_NAME
209 ": using %iK List Entry %d Memory\n",
210 list_count * Z2RAM_CHUNK1024, index);
211 } else
212 switch (device) {
213 case Z2MINOR_COMBINED:
214
215 z2ram_map =
216 kmalloc(max_z2_map + max_chip_map,
217 GFP_KERNEL);
218 if (z2ram_map == NULL) {
219 printk(KERN_ERR DEVICE_NAME
220 ": cannot get mem for z2ram_map\n");
221 goto err_out;
222 }
223
224 get_z2ram();
225 get_chipram();
226
227 if (z2ram_size != 0)
228 printk(KERN_INFO DEVICE_NAME
229 ": using %iK Zorro II RAM and %iK Chip RAM (Total %dK)\n",
230 z2_count * Z2RAM_CHUNK1024,
231 chip_count * Z2RAM_CHUNK1024,
232 (z2_count +
233 chip_count) * Z2RAM_CHUNK1024);
234
235 break;
236
237 case Z2MINOR_Z2ONLY:
238 z2ram_map = kmalloc(max_z2_map, GFP_KERNEL);
239 if (z2ram_map == NULL) {
240 printk(KERN_ERR DEVICE_NAME
241 ": cannot get mem for z2ram_map\n");
242 goto err_out;
243 }
244
245 get_z2ram();
246
247 if (z2ram_size != 0)
248 printk(KERN_INFO DEVICE_NAME
249 ": using %iK of Zorro II RAM\n",
250 z2_count * Z2RAM_CHUNK1024);
251
252 break;
253
254 case Z2MINOR_CHIPONLY:
255 z2ram_map = kmalloc(max_chip_map, GFP_KERNEL);
256 if (z2ram_map == NULL) {
257 printk(KERN_ERR DEVICE_NAME
258 ": cannot get mem for z2ram_map\n");
259 goto err_out;
260 }
261
262 get_chipram();
263
264 if (z2ram_size != 0)
265 printk(KERN_INFO DEVICE_NAME
266 ": using %iK Chip RAM\n",
267 chip_count * Z2RAM_CHUNK1024);
268
269 break;
270
271 default:
272 rc = -ENODEV;
273 goto err_out;
274
275 break;
276 }
277
278 if (z2ram_size == 0) {
279 printk(KERN_NOTICE DEVICE_NAME
280 ": no unused ZII/Chip RAM found\n");
281 goto err_out_kfree;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 }
283
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100284 current_device = device;
285 z2ram_size <<= Z2RAM_CHUNKSHIFT;
Christoph Hellwig76487f02020-10-29 15:58:40 +0100286 set_capacity(z2ram_gendisk[device], z2ram_size >> 9);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 }
288
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100289 mutex_unlock(&z2ram_mutex);
290 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292err_out_kfree:
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100293 kfree(z2ram_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294err_out:
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100295 mutex_unlock(&z2ram_mutex);
296 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297}
298
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100299static void z2_release(struct gendisk *disk, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300{
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100301 mutex_lock(&z2ram_mutex);
302 if (current_device == -1) {
303 mutex_unlock(&z2ram_mutex);
304 return;
305 }
306 mutex_unlock(&z2ram_mutex);
307 /*
308 * FIXME: unmap memory
309 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310}
311
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100312static const struct block_device_operations z2_fops = {
313 .owner = THIS_MODULE,
314 .open = z2_open,
315 .release = z2_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316};
317
Jens Axboe8535fd62018-10-15 09:02:45 -0600318static struct blk_mq_tag_set tag_set;
319
320static const struct blk_mq_ops z2_mq_ops = {
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100321 .queue_rq = z2_queue_rq,
Jens Axboe8535fd62018-10-15 09:02:45 -0600322};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
Christoph Hellwig76487f02020-10-29 15:58:40 +0100324static int z2ram_register_disk(int minor)
325{
326 struct request_queue *q;
327 struct gendisk *disk;
328
329 disk = alloc_disk(1);
330 if (!disk)
331 return -ENOMEM;
332
333 q = blk_mq_init_queue(&tag_set);
334 if (IS_ERR(q)) {
335 put_disk(disk);
336 return PTR_ERR(q);
337 }
338
339 disk->major = Z2RAM_MAJOR;
340 disk->first_minor = minor;
341 disk->fops = &z2_fops;
342 if (minor)
343 sprintf(disk->disk_name, "z2ram%d", minor);
344 else
345 sprintf(disk->disk_name, "z2ram");
346 disk->queue = q;
347
348 z2ram_gendisk[minor] = disk;
349 add_disk(disk);
350 return 0;
351}
352
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100353static int __init z2_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354{
Christoph Hellwig76487f02020-10-29 15:58:40 +0100355 int ret, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100357 if (!MACH_IS_AMIGA)
358 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100360 if (register_blkdev(Z2RAM_MAJOR, DEVICE_NAME))
Christoph Hellwig76487f02020-10-29 15:58:40 +0100361 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
Christoph Hellwig76487f02020-10-29 15:58:40 +0100363 tag_set.ops = &z2_mq_ops;
364 tag_set.nr_hw_queues = 1;
365 tag_set.nr_maps = 1;
366 tag_set.queue_depth = 16;
367 tag_set.numa_node = NUMA_NO_NODE;
368 tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
369 ret = blk_mq_alloc_tag_set(&tag_set);
370 if (ret)
371 goto out_unregister_blkdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
Christoph Hellwig76487f02020-10-29 15:58:40 +0100373 for (i = 0; i < Z2MINOR_COUNT; i++) {
374 ret = z2ram_register_disk(i);
375 if (ret && i == 0)
376 goto out_free_tagset;
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100377 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100379 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
Christoph Hellwig76487f02020-10-29 15:58:40 +0100381out_free_tagset:
382 blk_mq_free_tag_set(&tag_set);
383out_unregister_blkdev:
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100384 unregister_blkdev(Z2RAM_MAJOR, DEVICE_NAME);
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100385 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386}
387
Al Virof39d88a2006-10-11 17:28:47 +0100388static void __exit z2_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389{
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100390 int i, j;
Christoph Hellwig76487f02020-10-29 15:58:40 +0100391
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100392 unregister_blkdev(Z2RAM_MAJOR, DEVICE_NAME);
Christoph Hellwig76487f02020-10-29 15:58:40 +0100393
394 for (i = 0; i < Z2MINOR_COUNT; i++) {
395 del_gendisk(z2ram_gendisk[i]);
396 blk_cleanup_queue(z2ram_gendisk[i]->queue);
397 put_disk(z2ram_gendisk[i]);
398 }
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100399 blk_mq_free_tag_set(&tag_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100401 if (current_device != -1) {
402 i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100404 for (j = 0; j < z2_count; j++) {
405 set_bit(i++, zorro_unused_z2ram);
406 }
407
408 for (j = 0; j < chip_count; j++) {
409 if (z2ram_map[i]) {
410 amiga_chip_free((void *)z2ram_map[i++]);
411 }
412 }
413
414 if (z2ram_map != NULL) {
415 kfree(z2ram_map);
416 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 }
418
Christoph Hellwig6c3a05e2020-10-29 15:58:39 +0100419 return;
420}
Al Virof39d88a2006-10-11 17:28:47 +0100421
422module_init(z2_init);
423module_exit(z2_exit);
424MODULE_LICENSE("GPL");