1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Support for the N64 cart. 4 * 5 * Copyright (c) 2021 Lauri Kasanen 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 #include <linux/bitops.h> 10 #include <linux/blkdev.h> 11 #include <linux/dma-mapping.h> 12 #include <linux/init.h> 13 #include <linux/module.h> 14 #include <linux/platform_device.h> 15 16 static unsigned int start, size; 17 static u32 __iomem *reg_base; 18 static struct device *dev; 19 20 #define PI_DRAM_REG 0 21 #define PI_CART_REG 1 22 #define PI_READ_REG 2 23 #define PI_WRITE_REG 3 24 #define PI_STATUS_REG 4 25 26 #define PI_STATUS_DMA_BUSY (1 << 0) 27 #define PI_STATUS_IO_BUSY (1 << 1) 28 29 #define CART_DOMAIN 0x10000000 30 #define CART_MAX 0x1FFFFFFF 31 32 #define MIN_ALIGNMENT 8 33 34 static void n64cart_write_reg(const u8 reg, const u32 value) 35 { 36 writel(value, reg_base + reg); 37 } 38 39 static u32 n64cart_read_reg(const u8 reg) 40 { 41 return readl(reg_base + reg); 42 } 43 44 static void n64cart_wait_dma(void) 45 { 46 while (n64cart_read_reg(PI_STATUS_REG) & 47 (PI_STATUS_DMA_BUSY | PI_STATUS_IO_BUSY)) 48 cpu_relax(); 49 } 50 51 /* 52 * Process a single bvec of a bio. 53 */ 54 static bool n64cart_do_bvec(struct device *dev, struct bio_vec *bv, u32 pos) 55 { 56 dma_addr_t dma_addr; 57 const u32 bstart = pos + start; 58 59 /* Alignment check */ 60 WARN_ON_ONCE((bv->bv_offset & (MIN_ALIGNMENT - 1)) || 61 (bv->bv_len & (MIN_ALIGNMENT - 1))); 62 63 dma_addr = dma_map_bvec(dev, bv, DMA_FROM_DEVICE, 0); 64 if (dma_mapping_error(dev, dma_addr)) 65 return false; 66 67 n64cart_wait_dma(); 68 69 n64cart_write_reg(PI_DRAM_REG, dma_addr + bv->bv_offset); 70 n64cart_write_reg(PI_CART_REG, (bstart | CART_DOMAIN) & CART_MAX); 71 n64cart_write_reg(PI_WRITE_REG, bv->bv_len - 1); 72 73 n64cart_wait_dma(); 74 75 dma_unmap_page(dev, dma_addr, bv->bv_len, DMA_FROM_DEVICE); 76 return true; 77 } 78 79 static blk_qc_t n64cart_submit_bio(struct bio *bio) 80 { 81 struct bio_vec bvec; 82 u32 pos; 83 struct bvec_iter iter; 84 85 pos = bio->bi_iter.bi_sector << SECTOR_SHIFT; 86 87 bio_for_each_segment(bvec, bio, iter) { 88 if (!n64cart_do_bvec(dev, &bvec, pos)) 89 goto io_error; 90 pos += bvec.bv_len; 91 } 92 93 bio_endio(bio); 94 return BLK_QC_T_NONE; 95 io_error: 96 bio_io_error(bio); 97 return BLK_QC_T_NONE; 98 } 99 100 static const struct block_device_operations n64cart_fops = { 101 .owner = THIS_MODULE, 102 .submit_bio = n64cart_submit_bio, 103 }; 104 105 /* 106 * The target device is embedded and RAM-constrained. We save RAM 107 * by initializing in __init code that gets dropped late in boot. 108 * For the same reason there is no module or unloading support. 109 */ 110 static int __init n64cart_probe(struct platform_device *pdev) 111 { 112 int err; 113 struct request_queue *queue; 114 struct gendisk *disk; 115 116 if (!start || !size) { 117 pr_err("start or size not specified\n"); 118 return -ENODEV; 119 } 120 121 if (size & 4095) { 122 pr_err("size must be a multiple of 4K\n"); 123 return -ENODEV; 124 } 125 126 queue = blk_alloc_queue(NUMA_NO_NODE); 127 if (!queue) { 128 return -ENOMEM; 129 } 130 131 reg_base = devm_platform_ioremap_resource(pdev, 0); 132 if (!reg_base) { 133 err = -EINVAL; 134 goto fail_queue; 135 } 136 137 disk = alloc_disk(0); 138 if (!disk) { 139 err = -ENOMEM; 140 goto fail_queue; 141 } 142 143 dev = &pdev->dev; 144 145 disk->first_minor = 0; 146 disk->queue = queue; 147 disk->flags = GENHD_FL_NO_PART_SCAN | GENHD_FL_EXT_DEVT; 148 disk->fops = &n64cart_fops; 149 strcpy(disk->disk_name, "n64cart"); 150 151 set_capacity(disk, size / 512); 152 set_disk_ro(disk, 1); 153 154 blk_queue_flag_set(QUEUE_FLAG_NONROT, queue); 155 blk_queue_physical_block_size(queue, 4096); 156 blk_queue_logical_block_size(queue, 4096); 157 158 add_disk(disk); 159 160 pr_info("n64cart: %u kb disk\n", size / 1024); 161 162 return 0; 163 fail_queue: 164 blk_cleanup_queue(queue); 165 166 return err; 167 } 168 169 static struct platform_driver n64cart_driver = { 170 .driver = { 171 .name = "n64cart", 172 }, 173 }; 174 175 static int __init n64cart_init(void) 176 { 177 return platform_driver_probe(&n64cart_driver, n64cart_probe); 178 } 179 180 module_param(start, uint, 0); 181 MODULE_PARM_DESC(start, "Start address of the cart block data"); 182 183 module_param(size, uint, 0); 184 MODULE_PARM_DESC(size, "Size of the cart block data, in bytes"); 185 186 module_init(n64cart_init); 187 188 MODULE_AUTHOR("Lauri Kasanen <cand@gmx.com>"); 189 MODULE_DESCRIPTION("Driver for the N64 cart"); 190 MODULE_LICENSE("GPL"); 191