1/*
2 * File...........: arch/s390/mm/extmem.c
3 * Author(s)......: Carsten Otte <cotte@de.ibm.com>
4 * 		    Rob M van der Heij <rvdheij@nl.ibm.com>
5 * 		    Steven Shultz <shultzss@us.ibm.com>
6 * Bugreports.to..: <Linux390@de.ibm.com>
7 * (C) IBM Corporation 2002-2004
8 */
9
10#include <linux/kernel.h>
11#include <linux/string.h>
12#include <linux/spinlock.h>
13#include <linux/list.h>
14#include <linux/slab.h>
15#include <linux/module.h>
16#include <linux/bootmem.h>
17#include <linux/ctype.h>
18#include <linux/ioport.h>
19#include <asm/page.h>
20#include <asm/pgtable.h>
21#include <asm/ebcdic.h>
22#include <asm/errno.h>
23#include <asm/extmem.h>
24#include <asm/cpcmd.h>
25#include <asm/setup.h>
26
27#define DCSS_DEBUG	/* Debug messages on/off */
28
29#define DCSS_NAME "extmem"
30#ifdef DCSS_DEBUG
31#define PRINT_DEBUG(x...)	printk(KERN_DEBUG DCSS_NAME " debug:" x)
32#else
33#define PRINT_DEBUG(x...)   do {} while (0)
34#endif
35#define PRINT_INFO(x...)	printk(KERN_INFO DCSS_NAME " info:" x)
36#define PRINT_WARN(x...)	printk(KERN_WARNING DCSS_NAME " warning:" x)
37#define PRINT_ERR(x...)		printk(KERN_ERR DCSS_NAME " error:" x)
38
39
40#define DCSS_LOADSHR    0x00
41#define DCSS_LOADNSR    0x04
42#define DCSS_PURGESEG   0x08
43#define DCSS_FINDSEG    0x0c
44#define DCSS_LOADNOLY   0x10
45#define DCSS_SEGEXT     0x18
46#define DCSS_FINDSEGA   0x0c
47
48struct qrange {
49	unsigned int  start; // 3byte start address, 1 byte type
50	unsigned int  end;   // 3byte end address, 1 byte reserved
51};
52
53struct qout64 {
54	int segstart;
55	int segend;
56	int segcnt;
57	int segrcnt;
58	struct qrange range[6];
59};
60
61struct qin64 {
62	char qopcode;
63	char rsrv1[3];
64	char qrcode;
65	char rsrv2[3];
66	char qname[8];
67	unsigned int qoutptr;
68	short int qoutlen;
69};
70
71struct dcss_segment {
72	struct list_head list;
73	char dcss_name[8];
74	char res_name[15];
75	unsigned long start_addr;
76	unsigned long end;
77	atomic_t ref_count;
78	int do_nonshared;
79	unsigned int vm_segtype;
80	struct qrange range[6];
81	int segcnt;
82	struct resource *res;
83};
84
85static DEFINE_MUTEX(dcss_lock);
86static struct list_head dcss_list = LIST_HEAD_INIT(dcss_list);
87static char *segtype_string[] = { "SW", "EW", "SR", "ER", "SN", "EN", "SC",
88					"EW/EN-MIXED" };
89
90/*
91 * Create the 8 bytes, ebcdic VM segment name from
92 * an ascii name.
93 */
94static void
95dcss_mkname(char *name, char *dcss_name)
96{
97	int i;
98
99	for (i = 0; i < 8; i++) {
100		if (name[i] == '\0')
101			break;
102		dcss_name[i] = toupper(name[i]);
103	};
104	for (; i < 8; i++)
105		dcss_name[i] = ' ';
106	ASCEBC(dcss_name, 8);
107}
108
109
110/*
111 * search all segments in dcss_list, and return the one
112 * namend *name. If not found, return NULL.
113 */
114static struct dcss_segment *
115segment_by_name (char *name)
116{
117	char dcss_name[9];
118	struct list_head *l;
119	struct dcss_segment *tmp, *retval = NULL;
120
121	BUG_ON(!mutex_is_locked(&dcss_lock));
122	dcss_mkname (name, dcss_name);
123	list_for_each (l, &dcss_list) {
124		tmp = list_entry (l, struct dcss_segment, list);
125		if (memcmp(tmp->dcss_name, dcss_name, 8) == 0) {
126			retval = tmp;
127			break;
128		}
129	}
130	return retval;
131}
132
133
134/*
135 * Perform a function on a dcss segment.
136 */
137static inline int
138dcss_diag (__u8 func, void *parameter,
139           unsigned long *ret1, unsigned long *ret2)
140{
141	unsigned long rx, ry;
142	int rc;
143
144	rx = (unsigned long) parameter;
145	ry = (unsigned long) func;
146	asm volatile(
147#ifdef CONFIG_64BIT
148		"	sam31\n"
149		"	diag	%0,%1,0x64\n"
150		"	sam64\n"
151#else
152		"	diag	%0,%1,0x64\n"
153#endif
154		"	ipm	%2\n"
155		"	srl	%2,28\n"
156		: "+d" (rx), "+d" (ry), "=d" (rc) : : "cc");
157	*ret1 = rx;
158	*ret2 = ry;
159	return rc;
160}
161
162static inline int
163dcss_diag_translate_rc (int vm_rc) {
164	if (vm_rc == 44)
165		return -ENOENT;
166	return -EIO;
167}
168
169
170/* do a diag to get info about a segment.
171 * fills start_address, end and vm_segtype fields
172 */
173static int
174query_segment_type (struct dcss_segment *seg)
175{
176	struct qin64  *qin = kmalloc (sizeof(struct qin64), GFP_DMA);
177	struct qout64 *qout = kmalloc (sizeof(struct qout64), GFP_DMA);
178
179	int diag_cc, rc, i;
180	unsigned long dummy, vmrc;
181
182	if ((qin == NULL) || (qout == NULL)) {
183		rc = -ENOMEM;
184		goto out_free;
185	}
186
187	/* initialize diag input parameters */
188	qin->qopcode = DCSS_FINDSEGA;
189	qin->qoutptr = (unsigned long) qout;
190	qin->qoutlen = sizeof(struct qout64);
191	memcpy (qin->qname, seg->dcss_name, 8);
192
193	diag_cc = dcss_diag (DCSS_SEGEXT, qin, &dummy, &vmrc);
194
195	if (diag_cc > 1) {
196		PRINT_WARN ("segment_type: diag returned error %ld\n", vmrc);
197		rc = dcss_diag_translate_rc (vmrc);
198		goto out_free;
199	}
200
201	if (qout->segcnt > 6) {
202		rc = -ENOTSUPP;
203		goto out_free;
204	}
205
206	if (qout->segcnt == 1) {
207		seg->vm_segtype = qout->range[0].start & 0xff;
208	} else {
209		/* multi-part segment. only one type supported here:
210		    - all parts are contiguous
211		    - all parts are either EW or EN type
212		    - maximum 6 parts allowed */
213		unsigned long start = qout->segstart >> PAGE_SHIFT;
214		for (i=0; i<qout->segcnt; i++) {
215			if (((qout->range[i].start & 0xff) != SEG_TYPE_EW) &&
216			    ((qout->range[i].start & 0xff) != SEG_TYPE_EN)) {
217				rc = -ENOTSUPP;
218				goto out_free;
219			}
220			if (start != qout->range[i].start >> PAGE_SHIFT) {
221				rc = -ENOTSUPP;
222				goto out_free;
223			}
224			start = (qout->range[i].end >> PAGE_SHIFT) + 1;
225		}
226		seg->vm_segtype = SEG_TYPE_EWEN;
227	}
228
229	/* analyze diag output and update seg */
230	seg->start_addr = qout->segstart;
231	seg->end = qout->segend;
232
233	memcpy (seg->range, qout->range, 6*sizeof(struct qrange));
234	seg->segcnt = qout->segcnt;
235
236	rc = 0;
237
238 out_free:
239	kfree(qin);
240	kfree(qout);
241	return rc;
242}
243
244/*
245 * get info about a segment
246 * possible return values:
247 * -ENOSYS  : we are not running on VM
248 * -EIO     : could not perform query diagnose
249 * -ENOENT  : no such segment
250 * -ENOTSUPP: multi-part segment cannot be used with linux
251 * -ENOSPC  : segment cannot be used (overlaps with storage)
252 * -ENOMEM  : out of memory
253 * 0 .. 6   : type of segment as defined in include/asm-s390/extmem.h
254 */
255int
256segment_type (char* name)
257{
258	int rc;
259	struct dcss_segment seg;
260
261	if (!MACHINE_IS_VM)
262		return -ENOSYS;
263
264	dcss_mkname(name, seg.dcss_name);
265	rc = query_segment_type (&seg);
266	if (rc < 0)
267		return rc;
268	return seg.vm_segtype;
269}
270
271/*
272 * real segment loading function, called from segment_load
273 */
274static int
275__segment_load (char *name, int do_nonshared, unsigned long *addr, unsigned long *end)
276{
277	struct dcss_segment *seg = kmalloc(sizeof(struct dcss_segment),
278			GFP_DMA);
279	int dcss_command, rc, diag_cc;
280
281	if (seg == NULL) {
282		rc = -ENOMEM;
283		goto out;
284	}
285	dcss_mkname (name, seg->dcss_name);
286	rc = query_segment_type (seg);
287	if (rc < 0)
288		goto out_free;
289
290	rc = add_shared_memory(seg->start_addr, seg->end - seg->start_addr + 1);
291
292	switch (rc) {
293	case 0:
294		break;
295	case -ENOSPC:
296		PRINT_WARN("segment_load: not loading segment %s - overlaps "
297			   "storage/segment\n", name);
298		goto out_free;
299	case -ERANGE:
300		PRINT_WARN("segment_load: not loading segment %s - exceeds "
301			   "kernel mapping range\n", name);
302		goto out_free;
303	default:
304		PRINT_WARN("segment_load: not loading segment %s (rc: %d)\n",
305			   name, rc);
306		goto out_free;
307	}
308
309	seg->res = kzalloc(sizeof(struct resource), GFP_KERNEL);
310	if (seg->res == NULL) {
311		rc = -ENOMEM;
312		goto out_shared;
313	}
314	seg->res->flags = IORESOURCE_BUSY | IORESOURCE_MEM;
315	seg->res->start = seg->start_addr;
316	seg->res->end = seg->end;
317	memcpy(&seg->res_name, seg->dcss_name, 8);
318	EBCASC(seg->res_name, 8);
319	seg->res_name[8] = '\0';
320	strncat(seg->res_name, " (DCSS)", 7);
321	seg->res->name = seg->res_name;
322	rc = seg->vm_segtype;
323	if (rc == SEG_TYPE_SC ||
324	    ((rc == SEG_TYPE_SR || rc == SEG_TYPE_ER) && !do_nonshared))
325		seg->res->flags |= IORESOURCE_READONLY;
326	if (request_resource(&iomem_resource, seg->res)) {
327		rc = -EBUSY;
328		kfree(seg->res);
329		goto out_shared;
330	}
331
332	if (do_nonshared)
333		dcss_command = DCSS_LOADNSR;
334	else
335		dcss_command = DCSS_LOADNOLY;
336
337	diag_cc = dcss_diag(dcss_command, seg->dcss_name,
338			&seg->start_addr, &seg->end);
339	if (diag_cc > 1) {
340		PRINT_WARN ("segment_load: could not load segment %s - "
341				"diag returned error (%ld)\n",name,seg->end);
342		rc = dcss_diag_translate_rc (seg->end);
343		dcss_diag(DCSS_PURGESEG, seg->dcss_name,
344				&seg->start_addr, &seg->end);
345		goto out_resource;
346	}
347	seg->do_nonshared = do_nonshared;
348	atomic_set(&seg->ref_count, 1);
349	list_add(&seg->list, &dcss_list);
350	*addr = seg->start_addr;
351	*end  = seg->end;
352	if (do_nonshared)
353		PRINT_INFO ("segment_load: loaded segment %s range %p .. %p "
354				"type %s in non-shared mode\n", name,
355				(void*)seg->start_addr, (void*)seg->end,
356				segtype_string[seg->vm_segtype]);
357	else {
358		PRINT_INFO ("segment_load: loaded segment %s range %p .. %p "
359				"type %s in shared mode\n", name,
360				(void*)seg->start_addr, (void*)seg->end,
361				segtype_string[seg->vm_segtype]);
362	}
363	goto out;
364 out_resource:
365	release_resource(seg->res);
366	kfree(seg->res);
367 out_shared:
368	remove_shared_memory(seg->start_addr, seg->end - seg->start_addr + 1);
369 out_free:
370	kfree(seg);
371 out:
372	return rc;
373}
374
375/*
376 * this function loads a DCSS segment
377 * name         : name of the DCSS
378 * do_nonshared : 0 indicates that the dcss should be shared with other linux images
379 *                1 indicates that the dcss should be exclusive for this linux image
380 * addr         : will be filled with start address of the segment
381 * end          : will be filled with end address of the segment
382 * return values:
383 * -ENOSYS  : we are not running on VM
384 * -EIO     : could not perform query or load diagnose
385 * -ENOENT  : no such segment
386 * -ENOTSUPP: multi-part segment cannot be used with linux
387 * -ENOSPC  : segment cannot be used (overlaps with storage)
388 * -EBUSY   : segment can temporarily not be used (overlaps with dcss)
389 * -ERANGE  : segment cannot be used (exceeds kernel mapping range)
390 * -EPERM   : segment is currently loaded with incompatible permissions
391 * -ENOMEM  : out of memory
392 * 0 .. 6   : type of segment as defined in include/asm-s390/extmem.h
393 */
394int
395segment_load (char *name, int do_nonshared, unsigned long *addr,
396		unsigned long *end)
397{
398	struct dcss_segment *seg;
399	int rc;
400
401	if (!MACHINE_IS_VM)
402		return -ENOSYS;
403
404	mutex_lock(&dcss_lock);
405	seg = segment_by_name (name);
406	if (seg == NULL)
407		rc = __segment_load (name, do_nonshared, addr, end);
408	else {
409		if (do_nonshared == seg->do_nonshared) {
410			atomic_inc(&seg->ref_count);
411			*addr = seg->start_addr;
412			*end  = seg->end;
413			rc    = seg->vm_segtype;
414		} else {
415			*addr = *end = 0;
416			rc    = -EPERM;
417		}
418	}
419	mutex_unlock(&dcss_lock);
420	return rc;
421}
422
423/*
424 * this function modifies the shared state of a DCSS segment. note that
425 * name         : name of the DCSS
426 * do_nonshared : 0 indicates that the dcss should be shared with other linux images
427 *                1 indicates that the dcss should be exclusive for this linux image
428 * return values:
429 * -EIO     : could not perform load diagnose (segment gone!)
430 * -ENOENT  : no such segment (segment gone!)
431 * -EAGAIN  : segment is in use by other exploiters, try later
432 * -EINVAL  : no segment with the given name is currently loaded - name invalid
433 * -EBUSY   : segment can temporarily not be used (overlaps with dcss)
434 * 0	    : operation succeeded
435 */
436int
437segment_modify_shared (char *name, int do_nonshared)
438{
439	struct dcss_segment *seg;
440	unsigned long dummy;
441	int dcss_command, rc, diag_cc;
442
443	mutex_lock(&dcss_lock);
444	seg = segment_by_name (name);
445	if (seg == NULL) {
446		rc = -EINVAL;
447		goto out_unlock;
448	}
449	if (do_nonshared == seg->do_nonshared) {
450		PRINT_INFO ("segment_modify_shared: not reloading segment %s"
451				" - already in requested mode\n",name);
452		rc = 0;
453		goto out_unlock;
454	}
455	if (atomic_read (&seg->ref_count) != 1) {
456		PRINT_WARN ("segment_modify_shared: not reloading segment %s - "
457				"segment is in use by other driver(s)\n",name);
458		rc = -EAGAIN;
459		goto out_unlock;
460	}
461	release_resource(seg->res);
462	if (do_nonshared) {
463		dcss_command = DCSS_LOADNSR;
464		seg->res->flags &= ~IORESOURCE_READONLY;
465	} else {
466		dcss_command = DCSS_LOADNOLY;
467		if (seg->vm_segtype == SEG_TYPE_SR ||
468		    seg->vm_segtype == SEG_TYPE_ER)
469			seg->res->flags |= IORESOURCE_READONLY;
470	}
471	if (request_resource(&iomem_resource, seg->res)) {
472		PRINT_WARN("segment_modify_shared: could not reload segment %s"
473			   " - overlapping resources\n", name);
474		rc = -EBUSY;
475		kfree(seg->res);
476		goto out_del;
477	}
478	dcss_diag(DCSS_PURGESEG, seg->dcss_name, &dummy, &dummy);
479	diag_cc = dcss_diag(dcss_command, seg->dcss_name,
480			&seg->start_addr, &seg->end);
481	if (diag_cc > 1) {
482		PRINT_WARN ("segment_modify_shared: could not reload segment %s"
483				" - diag returned error (%ld)\n",name,seg->end);
484		rc = dcss_diag_translate_rc (seg->end);
485		goto out_del;
486	}
487	seg->do_nonshared = do_nonshared;
488	rc = 0;
489	goto out_unlock;
490 out_del:
491	remove_shared_memory(seg->start_addr, seg->end - seg->start_addr + 1);
492	list_del(&seg->list);
493	dcss_diag(DCSS_PURGESEG, seg->dcss_name, &dummy, &dummy);
494	kfree(seg);
495 out_unlock:
496	mutex_unlock(&dcss_lock);
497	return rc;
498}
499
500/*
501 * Decrease the use count of a DCSS segment and remove
502 * it from the address space if nobody is using it
503 * any longer.
504 */
505void
506segment_unload(char *name)
507{
508	unsigned long dummy;
509	struct dcss_segment *seg;
510
511	if (!MACHINE_IS_VM)
512		return;
513
514	mutex_lock(&dcss_lock);
515	seg = segment_by_name (name);
516	if (seg == NULL) {
517		PRINT_ERR ("could not find segment %s in segment_unload, "
518				"please report to linux390@de.ibm.com\n",name);
519		goto out_unlock;
520	}
521	if (atomic_dec_return(&seg->ref_count) != 0)
522		goto out_unlock;
523	release_resource(seg->res);
524	kfree(seg->res);
525	remove_shared_memory(seg->start_addr, seg->end - seg->start_addr + 1);
526	list_del(&seg->list);
527	dcss_diag(DCSS_PURGESEG, seg->dcss_name, &dummy, &dummy);
528	kfree(seg);
529out_unlock:
530	mutex_unlock(&dcss_lock);
531}
532
533/*
534 * save segment content permanently
535 */
536void
537segment_save(char *name)
538{
539	struct dcss_segment *seg;
540	int startpfn = 0;
541	int endpfn = 0;
542	char cmd1[160];
543	char cmd2[80];
544	int i, response;
545
546	if (!MACHINE_IS_VM)
547		return;
548
549	mutex_lock(&dcss_lock);
550	seg = segment_by_name (name);
551
552	if (seg == NULL) {
553		PRINT_ERR("could not find segment %s in segment_save, please "
554			  "report to linux390@de.ibm.com\n", name);
555		goto out;
556	}
557
558	startpfn = seg->start_addr >> PAGE_SHIFT;
559	endpfn = (seg->end) >> PAGE_SHIFT;
560	sprintf(cmd1, "DEFSEG %s", name);
561	for (i=0; i<seg->segcnt; i++) {
562		sprintf(cmd1+strlen(cmd1), " %X-%X %s",
563			seg->range[i].start >> PAGE_SHIFT,
564			seg->range[i].end >> PAGE_SHIFT,
565			segtype_string[seg->range[i].start & 0xff]);
566	}
567	sprintf(cmd2, "SAVESEG %s", name);
568	response = 0;
569	cpcmd(cmd1, NULL, 0, &response);
570	if (response) {
571		PRINT_ERR("segment_save: DEFSEG failed with response code %i\n",
572			  response);
573		goto out;
574	}
575	cpcmd(cmd2, NULL, 0, &response);
576	if (response) {
577		PRINT_ERR("segment_save: SAVESEG failed with response code %i\n",
578			  response);
579		goto out;
580	}
581out:
582	mutex_unlock(&dcss_lock);
583}
584
585EXPORT_SYMBOL(segment_load);
586EXPORT_SYMBOL(segment_unload);
587EXPORT_SYMBOL(segment_save);
588EXPORT_SYMBOL(segment_type);
589EXPORT_SYMBOL(segment_modify_shared);
590