1/*
2 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
3 *		    Martin Schwidefsky <schwidefsky@de.ibm.com>
4 * Bugreports.to..: <Linux390@de.ibm.com>
5 * Copyright IBM Corp. 2000
6 *
7 * History of changes
8 * 07/24/00 new file
9 * 05/04/02 code restructuring.
10 */
11
12#ifndef _S390_IDALS_H
13#define _S390_IDALS_H
14
15#include <linux/errno.h>
16#include <linux/err.h>
17#include <linux/types.h>
18#include <linux/slab.h>
19#include <asm/cio.h>
20#include <asm/uaccess.h>
21
22#define IDA_SIZE_LOG 12 /* 11 for 2k , 12 for 4k */
23#define IDA_BLOCK_SIZE (1L<<IDA_SIZE_LOG)
24
25/*
26 * Test if an address/length pair needs an idal list.
27 */
28static inline int
29idal_is_needed(void *vaddr, unsigned int length)
30{
31	return ((__pa(vaddr) + length - 1) >> 31) != 0;
32}
33
34
35/*
36 * Return the number of idal words needed for an address/length pair.
37 */
38static inline unsigned int idal_nr_words(void *vaddr, unsigned int length)
39{
40	return ((__pa(vaddr) & (IDA_BLOCK_SIZE-1)) + length +
41		(IDA_BLOCK_SIZE-1)) >> IDA_SIZE_LOG;
42}
43
44/*
45 * Create the list of idal words for an address/length pair.
46 */
47static inline unsigned long *idal_create_words(unsigned long *idaws,
48					       void *vaddr, unsigned int length)
49{
50	unsigned long paddr;
51	unsigned int cidaw;
52
53	paddr = __pa(vaddr);
54	cidaw = ((paddr & (IDA_BLOCK_SIZE-1)) + length +
55		 (IDA_BLOCK_SIZE-1)) >> IDA_SIZE_LOG;
56	*idaws++ = paddr;
57	paddr &= -IDA_BLOCK_SIZE;
58	while (--cidaw > 0) {
59		paddr += IDA_BLOCK_SIZE;
60		*idaws++ = paddr;
61	}
62	return idaws;
63}
64
65/*
66 * Sets the address of the data in CCW.
67 * If necessary it allocates an IDAL and sets the appropriate flags.
68 */
69static inline int
70set_normalized_cda(struct ccw1 * ccw, void *vaddr)
71{
72	unsigned int nridaws;
73	unsigned long *idal;
74
75	if (ccw->flags & CCW_FLAG_IDA)
76		return -EINVAL;
77	nridaws = idal_nr_words(vaddr, ccw->count);
78	if (nridaws > 0) {
79		idal = kmalloc(nridaws * sizeof(unsigned long),
80			       GFP_ATOMIC | GFP_DMA );
81		if (idal == NULL)
82			return -ENOMEM;
83		idal_create_words(idal, vaddr, ccw->count);
84		ccw->flags |= CCW_FLAG_IDA;
85		vaddr = idal;
86	}
87	ccw->cda = (__u32)(unsigned long) vaddr;
88	return 0;
89}
90
91/*
92 * Releases any allocated IDAL related to the CCW.
93 */
94static inline void
95clear_normalized_cda(struct ccw1 * ccw)
96{
97	if (ccw->flags & CCW_FLAG_IDA) {
98		kfree((void *)(unsigned long) ccw->cda);
99		ccw->flags &= ~CCW_FLAG_IDA;
100	}
101	ccw->cda = 0;
102}
103
104/*
105 * Idal buffer extension
106 */
107struct idal_buffer {
108	size_t size;
109	size_t page_order;
110	void *data[0];
111};
112
113/*
114 * Allocate an idal buffer
115 */
116static inline struct idal_buffer *
117idal_buffer_alloc(size_t size, int page_order)
118{
119	struct idal_buffer *ib;
120	int nr_chunks, nr_ptrs, i;
121
122	nr_ptrs = (size + IDA_BLOCK_SIZE - 1) >> IDA_SIZE_LOG;
123	nr_chunks = (4096 << page_order) >> IDA_SIZE_LOG;
124	ib = kmalloc(sizeof(struct idal_buffer) + nr_ptrs*sizeof(void *),
125		     GFP_DMA | GFP_KERNEL);
126	if (ib == NULL)
127		return ERR_PTR(-ENOMEM);
128	ib->size = size;
129	ib->page_order = page_order;
130	for (i = 0; i < nr_ptrs; i++) {
131		if ((i & (nr_chunks - 1)) != 0) {
132			ib->data[i] = ib->data[i-1] + IDA_BLOCK_SIZE;
133			continue;
134		}
135		ib->data[i] = (void *)
136			__get_free_pages(GFP_KERNEL, page_order);
137		if (ib->data[i] != NULL)
138			continue;
139		// Not enough memory
140		while (i >= nr_chunks) {
141			i -= nr_chunks;
142			free_pages((unsigned long) ib->data[i],
143				   ib->page_order);
144		}
145		kfree(ib);
146		return ERR_PTR(-ENOMEM);
147	}
148	return ib;
149}
150
151/*
152 * Free an idal buffer.
153 */
154static inline void
155idal_buffer_free(struct idal_buffer *ib)
156{
157	int nr_chunks, nr_ptrs, i;
158
159	nr_ptrs = (ib->size + IDA_BLOCK_SIZE - 1) >> IDA_SIZE_LOG;
160	nr_chunks = (4096 << ib->page_order) >> IDA_SIZE_LOG;
161	for (i = 0; i < nr_ptrs; i += nr_chunks)
162		free_pages((unsigned long) ib->data[i], ib->page_order);
163	kfree(ib);
164}
165
166/*
167 * Test if a idal list is really needed.
168 */
169static inline int
170__idal_buffer_is_needed(struct idal_buffer *ib)
171{
172	return ib->size > (4096ul << ib->page_order) ||
173		idal_is_needed(ib->data[0], ib->size);
174}
175
176/*
177 * Set channel data address to idal buffer.
178 */
179static inline void
180idal_buffer_set_cda(struct idal_buffer *ib, struct ccw1 *ccw)
181{
182	if (__idal_buffer_is_needed(ib)) {
183		// setup idals;
184		ccw->cda = (u32)(addr_t) ib->data;
185		ccw->flags |= CCW_FLAG_IDA;
186	} else
187		// we do not need idals - use direct addressing
188		ccw->cda = (u32)(addr_t) ib->data[0];
189	ccw->count = ib->size;
190}
191
192/*
193 * Copy count bytes from an idal buffer to user memory
194 */
195static inline size_t
196idal_buffer_to_user(struct idal_buffer *ib, void __user *to, size_t count)
197{
198	size_t left;
199	int i;
200
201	BUG_ON(count > ib->size);
202	for (i = 0; count > IDA_BLOCK_SIZE; i++) {
203		left = copy_to_user(to, ib->data[i], IDA_BLOCK_SIZE);
204		if (left)
205			return left + count - IDA_BLOCK_SIZE;
206		to = (void __user *) to + IDA_BLOCK_SIZE;
207		count -= IDA_BLOCK_SIZE;
208	}
209	return copy_to_user(to, ib->data[i], count);
210}
211
212/*
213 * Copy count bytes from user memory to an idal buffer
214 */
215static inline size_t
216idal_buffer_from_user(struct idal_buffer *ib, const void __user *from, size_t count)
217{
218	size_t left;
219	int i;
220
221	BUG_ON(count > ib->size);
222	for (i = 0; count > IDA_BLOCK_SIZE; i++) {
223		left = copy_from_user(ib->data[i], from, IDA_BLOCK_SIZE);
224		if (left)
225			return left + count - IDA_BLOCK_SIZE;
226		from = (void __user *) from + IDA_BLOCK_SIZE;
227		count -= IDA_BLOCK_SIZE;
228	}
229	return copy_from_user(ib->data[i], from, count);
230}
231
232#endif
233