1/* 2 * Xpram.c -- the S/390 expanded memory RAM-disk 3 * 4 * significant parts of this code are based on 5 * the sbull device driver presented in 6 * A. Rubini: Linux Device Drivers 7 * 8 * Author of XPRAM specific coding: Reinhard Buendgen 9 * buendgen@de.ibm.com 10 * Rewrite for 2.5: Martin Schwidefsky <schwidefsky@de.ibm.com> 11 * 12 * External interfaces: 13 * Interfaces to linux kernel 14 * xpram_setup: read kernel parameters 15 * Device specific file operations 16 * xpram_iotcl 17 * xpram_open 18 * 19 * "ad-hoc" partitioning: 20 * the expanded memory can be partitioned among several devices 21 * (with different minors). The partitioning set up can be 22 * set by kernel or module parameters (int devs & int sizes[]) 23 * 24 * Potential future improvements: 25 * generic hard disk support to replace ad-hoc partitioning 26 */ 27 28#define KMSG_COMPONENT "xpram" 29#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 30 31#include <linux/module.h> 32#include <linux/moduleparam.h> 33#include <linux/ctype.h> /* isdigit, isxdigit */ 34#include <linux/errno.h> 35#include <linux/init.h> 36#include <linux/blkdev.h> 37#include <linux/blkpg.h> 38#include <linux/hdreg.h> /* HDIO_GETGEO */ 39#include <linux/device.h> 40#include <linux/bio.h> 41#include <linux/suspend.h> 42#include <linux/platform_device.h> 43#include <linux/gfp.h> 44#include <asm/uaccess.h> 45 46#define XPRAM_NAME "xpram" 47#define XPRAM_DEVS 1 /* one partition */ 48#define XPRAM_MAX_DEVS 32 /* maximal number of devices (partitions) */ 49 50typedef struct { 51 unsigned int size; /* size of xpram segment in pages */ 52 unsigned int offset; /* start page of xpram segment */ 53} xpram_device_t; 54 55static xpram_device_t xpram_devices[XPRAM_MAX_DEVS]; 56static unsigned int xpram_sizes[XPRAM_MAX_DEVS]; 57static struct gendisk *xpram_disks[XPRAM_MAX_DEVS]; 58static struct request_queue *xpram_queues[XPRAM_MAX_DEVS]; 59static unsigned int xpram_pages; 60static int xpram_devs; 61 62/* 63 * Parameter parsing functions. 64 */ 65static int devs = XPRAM_DEVS; 66static char *sizes[XPRAM_MAX_DEVS]; 67 68module_param(devs, int, 0); 69module_param_array(sizes, charp, NULL, 0); 70 71MODULE_PARM_DESC(devs, "number of devices (\"partitions\"), " \ 72 "the default is " __MODULE_STRING(XPRAM_DEVS) "\n"); 73MODULE_PARM_DESC(sizes, "list of device (partition) sizes " \ 74 "the defaults are 0s \n" \ 75 "All devices with size 0 equally partition the " 76 "remaining space on the expanded strorage not " 77 "claimed by explicit sizes\n"); 78MODULE_LICENSE("GPL"); 79 80/* 81 * Copy expanded memory page (4kB) into main memory 82 * Arguments 83 * page_addr: address of target page 84 * xpage_index: index of expandeded memory page 85 * Return value 86 * 0: if operation succeeds 87 * -EIO: if pgin failed 88 * -ENXIO: if xpram has vanished 89 */ 90static int xpram_page_in (unsigned long page_addr, unsigned int xpage_index) 91{ 92 int cc = 2; /* return unused cc 2 if pgin traps */ 93 94 asm volatile( 95 " .insn rre,0xb22e0000,%1,%2\n" /* pgin %1,%2 */ 96 "0: ipm %0\n" 97 " srl %0,28\n" 98 "1:\n" 99 EX_TABLE(0b,1b) 100 : "+d" (cc) : "a" (__pa(page_addr)), "d" (xpage_index) : "cc"); 101 if (cc == 3) 102 return -ENXIO; 103 if (cc == 2) 104 return -ENXIO; 105 if (cc == 1) 106 return -EIO; 107 return 0; 108} 109 110/* 111 * Copy a 4kB page of main memory to an expanded memory page 112 * Arguments 113 * page_addr: address of source page 114 * xpage_index: index of expandeded memory page 115 * Return value 116 * 0: if operation succeeds 117 * -EIO: if pgout failed 118 * -ENXIO: if xpram has vanished 119 */ 120static long xpram_page_out (unsigned long page_addr, unsigned int xpage_index) 121{ 122 int cc = 2; /* return unused cc 2 if pgin traps */ 123 124 asm volatile( 125 " .insn rre,0xb22f0000,%1,%2\n" /* pgout %1,%2 */ 126 "0: ipm %0\n" 127 " srl %0,28\n" 128 "1:\n" 129 EX_TABLE(0b,1b) 130 : "+d" (cc) : "a" (__pa(page_addr)), "d" (xpage_index) : "cc"); 131 if (cc == 3) 132 return -ENXIO; 133 if (cc == 2) 134 return -ENXIO; 135 if (cc == 1) 136 return -EIO; 137 return 0; 138} 139 140/* 141 * Check if xpram is available. 142 */ 143static int xpram_present(void) 144{ 145 unsigned long mem_page; 146 int rc; 147 148 mem_page = (unsigned long) __get_free_page(GFP_KERNEL); 149 if (!mem_page) 150 return -ENOMEM; 151 rc = xpram_page_in(mem_page, 0); 152 free_page(mem_page); 153 return rc ? -ENXIO : 0; 154} 155 156/* 157 * Return index of the last available xpram page. 158 */ 159static unsigned long xpram_highest_page_index(void) 160{ 161 unsigned int page_index, add_bit; 162 unsigned long mem_page; 163 164 mem_page = (unsigned long) __get_free_page(GFP_KERNEL); 165 if (!mem_page) 166 return 0; 167 168 page_index = 0; 169 add_bit = 1ULL << (sizeof(unsigned int)*8 - 1); 170 while (add_bit > 0) { 171 if (xpram_page_in(mem_page, page_index | add_bit) == 0) 172 page_index |= add_bit; 173 add_bit >>= 1; 174 } 175 176 free_page (mem_page); 177 178 return page_index; 179} 180 181/* 182 * Block device make request function. 183 */ 184static blk_qc_t xpram_make_request(struct request_queue *q, struct bio *bio) 185{ 186 xpram_device_t *xdev = bio->bi_bdev->bd_disk->private_data; 187 struct bio_vec bvec; 188 struct bvec_iter iter; 189 unsigned int index; 190 unsigned long page_addr; 191 unsigned long bytes; 192 193 blk_queue_split(q, &bio, q->bio_split); 194 195 if ((bio->bi_iter.bi_sector & 7) != 0 || 196 (bio->bi_iter.bi_size & 4095) != 0) 197 /* Request is not page-aligned. */ 198 goto fail; 199 if ((bio->bi_iter.bi_size >> 12) > xdev->size) 200 /* Request size is no page-aligned. */ 201 goto fail; 202 if ((bio->bi_iter.bi_sector >> 3) > 0xffffffffU - xdev->offset) 203 goto fail; 204 index = (bio->bi_iter.bi_sector >> 3) + xdev->offset; 205 bio_for_each_segment(bvec, bio, iter) { 206 page_addr = (unsigned long) 207 kmap(bvec.bv_page) + bvec.bv_offset; 208 bytes = bvec.bv_len; 209 if ((page_addr & 4095) != 0 || (bytes & 4095) != 0) 210 /* More paranoia. */ 211 goto fail; 212 while (bytes > 0) { 213 if (bio_data_dir(bio) == READ) { 214 if (xpram_page_in(page_addr, index) != 0) 215 goto fail; 216 } else { 217 if (xpram_page_out(page_addr, index) != 0) 218 goto fail; 219 } 220 page_addr += 4096; 221 bytes -= 4096; 222 index++; 223 } 224 } 225 bio_endio(bio); 226 return BLK_QC_T_NONE; 227fail: 228 bio_io_error(bio); 229 return BLK_QC_T_NONE; 230} 231 232static int xpram_getgeo(struct block_device *bdev, struct hd_geometry *geo) 233{ 234 unsigned long size; 235 236 /* 237 * get geometry: we have to fake one... trim the size to a 238 * multiple of 64 (32k): tell we have 16 sectors, 4 heads, 239 * whatever cylinders. Tell also that data starts at sector. 4. 240 */ 241 size = (xpram_pages * 8) & ~0x3f; 242 geo->cylinders = size >> 6; 243 geo->heads = 4; 244 geo->sectors = 16; 245 geo->start = 4; 246 return 0; 247} 248 249static const struct block_device_operations xpram_devops = 250{ 251 .owner = THIS_MODULE, 252 .getgeo = xpram_getgeo, 253}; 254 255/* 256 * Setup xpram_sizes array. 257 */ 258static int __init xpram_setup_sizes(unsigned long pages) 259{ 260 unsigned long mem_needed; 261 unsigned long mem_auto; 262 unsigned long long size; 263 char *sizes_end; 264 int mem_auto_no; 265 int i; 266 267 /* Check number of devices. */ 268 if (devs <= 0 || devs > XPRAM_MAX_DEVS) { 269 pr_err("%d is not a valid number of XPRAM devices\n",devs); 270 return -EINVAL; 271 } 272 xpram_devs = devs; 273 274 /* 275 * Copy sizes array to xpram_sizes and align partition 276 * sizes to page boundary. 277 */ 278 mem_needed = 0; 279 mem_auto_no = 0; 280 for (i = 0; i < xpram_devs; i++) { 281 if (sizes[i]) { 282 size = simple_strtoull(sizes[i], &sizes_end, 0); 283 switch (*sizes_end) { 284 case 'g': 285 case 'G': 286 size <<= 20; 287 break; 288 case 'm': 289 case 'M': 290 size <<= 10; 291 } 292 xpram_sizes[i] = (size + 3) & -4UL; 293 } 294 if (xpram_sizes[i]) 295 mem_needed += xpram_sizes[i]; 296 else 297 mem_auto_no++; 298 } 299 300 pr_info(" number of devices (partitions): %d \n", xpram_devs); 301 for (i = 0; i < xpram_devs; i++) { 302 if (xpram_sizes[i]) 303 pr_info(" size of partition %d: %u kB\n", 304 i, xpram_sizes[i]); 305 else 306 pr_info(" size of partition %d to be set " 307 "automatically\n",i); 308 } 309 pr_info(" memory needed (for sized partitions): %lu kB\n", 310 mem_needed); 311 pr_info(" partitions to be sized automatically: %d\n", 312 mem_auto_no); 313 314 if (mem_needed > pages * 4) { 315 pr_err("Not enough expanded memory available\n"); 316 return -EINVAL; 317 } 318 319 /* 320 * partitioning: 321 * xpram_sizes[i] != 0; partition i has size xpram_sizes[i] kB 322 * else: ; all partitions with zero xpram_sizes[i] 323 * partition equally the remaining space 324 */ 325 if (mem_auto_no) { 326 mem_auto = ((pages - mem_needed / 4) / mem_auto_no) * 4; 327 pr_info(" automatically determined " 328 "partition size: %lu kB\n", mem_auto); 329 for (i = 0; i < xpram_devs; i++) 330 if (xpram_sizes[i] == 0) 331 xpram_sizes[i] = mem_auto; 332 } 333 return 0; 334} 335 336static int __init xpram_setup_blkdev(void) 337{ 338 unsigned long offset; 339 int i, rc = -ENOMEM; 340 341 for (i = 0; i < xpram_devs; i++) { 342 xpram_disks[i] = alloc_disk(1); 343 if (!xpram_disks[i]) 344 goto out; 345 xpram_queues[i] = blk_alloc_queue(GFP_KERNEL); 346 if (!xpram_queues[i]) { 347 put_disk(xpram_disks[i]); 348 goto out; 349 } 350 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, xpram_queues[i]); 351 queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, xpram_queues[i]); 352 blk_queue_make_request(xpram_queues[i], xpram_make_request); 353 blk_queue_logical_block_size(xpram_queues[i], 4096); 354 } 355 356 /* 357 * Register xpram major. 358 */ 359 rc = register_blkdev(XPRAM_MAJOR, XPRAM_NAME); 360 if (rc < 0) 361 goto out; 362 363 /* 364 * Setup device structures. 365 */ 366 offset = 0; 367 for (i = 0; i < xpram_devs; i++) { 368 struct gendisk *disk = xpram_disks[i]; 369 370 xpram_devices[i].size = xpram_sizes[i] / 4; 371 xpram_devices[i].offset = offset; 372 offset += xpram_devices[i].size; 373 disk->major = XPRAM_MAJOR; 374 disk->first_minor = i; 375 disk->fops = &xpram_devops; 376 disk->private_data = &xpram_devices[i]; 377 disk->queue = xpram_queues[i]; 378 sprintf(disk->disk_name, "slram%d", i); 379 set_capacity(disk, xpram_sizes[i] << 1); 380 add_disk(disk); 381 } 382 383 return 0; 384out: 385 while (i--) { 386 blk_cleanup_queue(xpram_queues[i]); 387 put_disk(xpram_disks[i]); 388 } 389 return rc; 390} 391 392/* 393 * Resume failed: Print error message and call panic. 394 */ 395static void xpram_resume_error(const char *message) 396{ 397 pr_err("Resuming the system failed: %s\n", message); 398 panic("xpram resume error\n"); 399} 400 401/* 402 * Check if xpram setup changed between suspend and resume. 403 */ 404static int xpram_restore(struct device *dev) 405{ 406 if (!xpram_pages) 407 return 0; 408 if (xpram_present() != 0) 409 xpram_resume_error("xpram disappeared"); 410 if (xpram_pages != xpram_highest_page_index() + 1) 411 xpram_resume_error("Size of xpram changed"); 412 return 0; 413} 414 415static const struct dev_pm_ops xpram_pm_ops = { 416 .restore = xpram_restore, 417}; 418 419static struct platform_driver xpram_pdrv = { 420 .driver = { 421 .name = XPRAM_NAME, 422 .pm = &xpram_pm_ops, 423 }, 424}; 425 426static struct platform_device *xpram_pdev; 427 428/* 429 * Finally, the init/exit functions. 430 */ 431static void __exit xpram_exit(void) 432{ 433 int i; 434 for (i = 0; i < xpram_devs; i++) { 435 del_gendisk(xpram_disks[i]); 436 blk_cleanup_queue(xpram_queues[i]); 437 put_disk(xpram_disks[i]); 438 } 439 unregister_blkdev(XPRAM_MAJOR, XPRAM_NAME); 440 platform_device_unregister(xpram_pdev); 441 platform_driver_unregister(&xpram_pdrv); 442} 443 444static int __init xpram_init(void) 445{ 446 int rc; 447 448 /* Find out size of expanded memory. */ 449 if (xpram_present() != 0) { 450 pr_err("No expanded memory available\n"); 451 return -ENODEV; 452 } 453 xpram_pages = xpram_highest_page_index() + 1; 454 pr_info(" %u pages expanded memory found (%lu KB).\n", 455 xpram_pages, (unsigned long) xpram_pages*4); 456 rc = xpram_setup_sizes(xpram_pages); 457 if (rc) 458 return rc; 459 rc = platform_driver_register(&xpram_pdrv); 460 if (rc) 461 return rc; 462 xpram_pdev = platform_device_register_simple(XPRAM_NAME, -1, NULL, 0); 463 if (IS_ERR(xpram_pdev)) { 464 rc = PTR_ERR(xpram_pdev); 465 goto fail_platform_driver_unregister; 466 } 467 rc = xpram_setup_blkdev(); 468 if (rc) 469 goto fail_platform_device_unregister; 470 return 0; 471 472fail_platform_device_unregister: 473 platform_device_unregister(xpram_pdev); 474fail_platform_driver_unregister: 475 platform_driver_unregister(&xpram_pdrv); 476 return rc; 477} 478 479module_init(xpram_init); 480module_exit(xpram_exit); 481