git.oblomov.eu Git - linux-2.6/blob - drivers/s390/cio/itcw.c

   1 /*
   2  *  Functions for incremental construction of fcx enabled I/O control blocks.
   3  *
   4  *    Copyright IBM Corp. 2008
   5  *    Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/types.h>
  10 #include <linux/string.h>
  11 #include <linux/errno.h>
  12 #include <linux/err.h>
  13 #include <linux/module.h>
  14 #include <asm/fcx.h>
  15 #include <asm/itcw.h>
  16
  17 /**
  18  * struct itcw - incremental tcw helper data type
  19  *
  20  * This structure serves as a handle for the incremental construction of a
  21  * tcw and associated tccb, tsb, data tidaw-list plus an optional interrogate
  22  * tcw and associated data. The data structures are contained inside a single
  23  * contiguous buffer provided by the user.
  24  *
  25  * The itcw construction functions take care of overall data integrity:
  26  * - reset unused fields to zero
  27  * - fill in required pointers
  28  * - ensure required alignment for data structures
  29  * - prevent data structures to cross 4k-byte boundary where required
  30  * - calculate tccb-related length fields
  31  * - optionally provide ready-made interrogate tcw and associated structures
  32  *
  33  * Restrictions apply to the itcws created with these construction functions:
  34  * - tida only supported for data address, not for tccb
  35  * - only contiguous tidaw-lists (no ttic)
  36  * - total number of bytes required per itcw may not exceed 4k bytes
  37  * - either read or write operation (may not work with r=0 and w=0)
  38  *
  39  * Example:
  40  * struct itcw *itcw;
  41  * void *buffer;
  42  * size_t size;
  43  *
  44  * size = itcw_calc_size(1, 2, 0);
  45  * buffer = kmalloc(size, GFP_DMA);
  46  * if (!buffer)
  47  *      return -ENOMEM;
  48  * itcw = itcw_init(buffer, size, ITCW_OP_READ, 1, 2, 0);
  49  * if (IS_ERR(itcw))
  50  *      return PTR_ER(itcw);
  51  * itcw_add_dcw(itcw, 0x2, 0, NULL, 0, 72);
  52  * itcw_add_tidaw(itcw, 0, 0x30000, 20);
  53  * itcw_add_tidaw(itcw, 0, 0x40000, 52);
  54  * itcw_finalize(itcw);
  55  *
  56  */
  57 struct itcw {
  58         struct tcw *tcw;
  59         struct tcw *intrg_tcw;
  60         int num_tidaws;
  61         int max_tidaws;
  62         int intrg_num_tidaws;
  63         int intrg_max_tidaws;
  64 };
  65
  66 /**
  67  * itcw_get_tcw - return pointer to tcw associated with the itcw
  68  * @itcw: address of the itcw
  69  *
  70  * Return pointer to the tcw associated with the itcw.
  71  */
  72 struct tcw *itcw_get_tcw(struct itcw *itcw)
  73 {
  74         return itcw->tcw;
  75 }
  76 EXPORT_SYMBOL(itcw_get_tcw);
  77
  78 /**
  79  * itcw_calc_size - return the size of an itcw with the given parameters
  80  * @intrg: if non-zero, add an interrogate tcw
  81  * @max_tidaws: maximum number of tidaws to be used for data addressing or zero
  82  * if no tida is to be used.
  83  * @intrg_max_tidaws: maximum number of tidaws to be used for data addressing
  84  * by the interrogate tcw, if specified
  85  *
  86  * Calculate and return the number of bytes required to hold an itcw with the
  87  * given parameters and assuming tccbs with maximum size.
  88  *
  89  * Note that the resulting size also contains bytes needed for alignment
  90  * padding as well as padding to ensure that data structures don't cross a
  91  * 4k-boundary where required.
  92  */
  93 size_t itcw_calc_size(int intrg, int max_tidaws, int intrg_max_tidaws)
  94 {
  95         size_t len;
  96
  97         /* Main data. */
  98         len = sizeof(struct itcw);
  99         len += /* TCW */ sizeof(struct tcw) + /* TCCB */ TCCB_MAX_SIZE +
 100                /* TSB */ sizeof(struct tsb) +
 101                /* TIDAL */ max_tidaws * sizeof(struct tidaw);
 102         /* Interrogate data. */
 103         if (intrg) {
 104                 len += /* TCW */ sizeof(struct tcw) + /* TCCB */ TCCB_MAX_SIZE +
 105                        /* TSB */ sizeof(struct tsb) +
 106                        /* TIDAL */ intrg_max_tidaws * sizeof(struct tidaw);
 107         }
 108         /* Maximum required alignment padding. */
 109         len += /* Initial TCW */ 63 + /* Interrogate TCCB */ 7;
 110         /* Maximum padding for structures that may not cross 4k boundary. */
 111         if ((max_tidaws > 0) || (intrg_max_tidaws > 0))
 112                 len += max(max_tidaws, intrg_max_tidaws) *
 113                        sizeof(struct tidaw) - 1;
 114         return len;
 115 }
 116 EXPORT_SYMBOL(itcw_calc_size);
 117
 118 #define CROSS4K(x, l)   (((x) & ~4095) != ((x + l) & ~4095))
 119
 120 static inline void *fit_chunk(addr_t *start, addr_t end, size_t len,
 121                               int align, int check_4k)
 122 {
 123         addr_t addr;
 124
 125         addr = ALIGN(*start, align);
 126         if (check_4k && CROSS4K(addr, len)) {
 127                 addr = ALIGN(addr, 4096);
 128                 addr = ALIGN(addr, align);
 129         }
 130         if (addr + len > end)
 131                 return ERR_PTR(-ENOSPC);
 132         *start = addr + len;
 133         return (void *) addr;
 134 }
 135
 136 /**
 137  * itcw_init - initialize incremental tcw data structure
 138  * @buffer: address of buffer to use for data structures
 139  * @size: number of bytes in buffer
 140  * @op: %ITCW_OP_READ for a read operation tcw, %ITCW_OP_WRITE for a write
 141  * operation tcw
 142  * @intrg: if non-zero, add and initialize an interrogate tcw
 143  * @max_tidaws: maximum number of tidaws to be used for data addressing or zero
 144  * if no tida is to be used.
 145  * @intrg_max_tidaws: maximum number of tidaws to be used for data addressing
 146  * by the interrogate tcw, if specified
 147  *
 148  * Prepare the specified buffer to be used as an incremental tcw, i.e. a
 149  * helper data structure that can be used to construct a valid tcw by
 150  * successive calls to other helper functions. Note: the buffer needs to be
 151  * located below the 2G address limit. The resulting tcw has the following
 152  * restrictions:
 153  *  - no tccb tidal
 154  *  - input/output tidal is contiguous (no ttic)
 155  *  - total data should not exceed 4k
 156  *  - tcw specifies either read or write operation
 157  *
 158  * On success, return pointer to the resulting incremental tcw data structure,
 159  * ERR_PTR otherwise.
 160  */
 161 struct itcw *itcw_init(void *buffer, size_t size, int op, int intrg,
 162                        int max_tidaws, int intrg_max_tidaws)
 163 {
 164         struct itcw *itcw;
 165         void *chunk;
 166         addr_t start;
 167         addr_t end;
 168
 169         /* Check for 2G limit. */
 170         start = (addr_t) buffer;
 171         end = start + size;
 172         if (end > (1 << 31))
 173                 return ERR_PTR(-EINVAL);
 174         memset(buffer, 0, size);
 175         /* ITCW. */
 176         chunk = fit_chunk(&start, end, sizeof(struct itcw), 1, 0);
 177         if (IS_ERR(chunk))
 178                 return chunk;
 179         itcw = chunk;
 180         itcw->max_tidaws = max_tidaws;
 181         itcw->intrg_max_tidaws = intrg_max_tidaws;
 182         /* Main TCW. */
 183         chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0);
 184         if (IS_ERR(chunk))
 185                 return chunk;
 186         itcw->tcw = chunk;
 187         tcw_init(itcw->tcw, (op == ITCW_OP_READ) ? 1 : 0,
 188                  (op == ITCW_OP_WRITE) ? 1 : 0);
 189         /* Interrogate TCW. */
 190         if (intrg) {
 191                 chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0);
 192                 if (IS_ERR(chunk))
 193                         return chunk;
 194                 itcw->intrg_tcw = chunk;
 195                 tcw_init(itcw->intrg_tcw, 1, 0);
 196                 tcw_set_intrg(itcw->tcw, itcw->intrg_tcw);
 197         }
 198         /* Data TIDAL. */
 199         if (max_tidaws > 0) {
 200                 chunk = fit_chunk(&start, end, sizeof(struct tidaw) *
 201                                   max_tidaws, 16, 1);
 202                 if (IS_ERR(chunk))
 203                         return chunk;
 204                 tcw_set_data(itcw->tcw, chunk, 1);
 205         }
 206         /* Interrogate data TIDAL. */
 207         if (intrg && (intrg_max_tidaws > 0)) {
 208                 chunk = fit_chunk(&start, end, sizeof(struct tidaw) *
 209                                   intrg_max_tidaws, 16, 1);
 210                 if (IS_ERR(chunk))
 211                         return chunk;
 212                 tcw_set_data(itcw->intrg_tcw, chunk, 1);
 213         }
 214         /* TSB. */
 215         chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0);
 216         if (IS_ERR(chunk))
 217                 return chunk;
 218         tsb_init(chunk);
 219         tcw_set_tsb(itcw->tcw, chunk);
 220         /* Interrogate TSB. */
 221         if (intrg) {
 222                 chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0);
 223                 if (IS_ERR(chunk))
 224                         return chunk;
 225                 tsb_init(chunk);
 226                 tcw_set_tsb(itcw->intrg_tcw, chunk);
 227         }
 228         /* TCCB. */
 229         chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0);
 230         if (IS_ERR(chunk))
 231                 return chunk;
 232         tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_DEFAULT);
 233         tcw_set_tccb(itcw->tcw, chunk);
 234         /* Interrogate TCCB. */
 235         if (intrg) {
 236                 chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0);
 237                 if (IS_ERR(chunk))
 238                         return chunk;
 239                 tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_INTRG);
 240                 tcw_set_tccb(itcw->intrg_tcw, chunk);
 241                 tccb_add_dcw(chunk, TCCB_MAX_SIZE, DCW_CMD_INTRG, 0, NULL,
 242                              sizeof(struct dcw_intrg_data), 0);
 243                 tcw_finalize(itcw->intrg_tcw, 0);
 244         }
 245         return itcw;
 246 }
 247 EXPORT_SYMBOL(itcw_init);
 248
 249 /**
 250  * itcw_add_dcw - add a dcw to the itcw
 251  * @itcw: address of the itcw
 252  * @cmd: the dcw command
 253  * @flags: flags for the dcw
 254  * @cd: address of control data for this dcw or NULL if none is required
 255  * @cd_count: number of control data bytes for this dcw
 256  * @count: number of data bytes for this dcw
 257  *
 258  * Add a new dcw to the specified itcw by writing the dcw information specified
 259  * by @cmd, @flags, @cd, @cd_count and @count to the tca of the tccb. Return
 260  * a pointer to the newly added dcw on success or -%ENOSPC if the new dcw
 261  * would exceed the available space.
 262  *
 263  * Note: the tcal field of the tccb header will be updated to reflect added
 264  * content.
 265  */
 266 struct dcw *itcw_add_dcw(struct itcw *itcw, u8 cmd, u8 flags, void *cd,
 267                          u8 cd_count, u32 count)
 268 {
 269         return tccb_add_dcw(tcw_get_tccb(itcw->tcw), TCCB_MAX_SIZE, cmd,
 270                             flags, cd, cd_count, count);
 271 }
 272 EXPORT_SYMBOL(itcw_add_dcw);
 273
 274 /**
 275  * itcw_add_tidaw - add a tidaw to the itcw
 276  * @itcw: address of the itcw
 277  * @flags: flags for the new tidaw
 278  * @addr: address value for the new tidaw
 279  * @count: count value for the new tidaw
 280  *
 281  * Add a new tidaw to the input/output data tidaw-list of the specified itcw
 282  * (depending on the value of the r-flag and w-flag). Return a pointer to
 283  * the new tidaw on success or -%ENOSPC if the new tidaw would exceed the
 284  * available space.
 285  *
 286  * Note: the tidaw-list is assumed to be contiguous with no ttics. The
 287  * last-tidaw flag for the last tidaw in the list will be set by itcw_finalize.
 288  */
 289 struct tidaw *itcw_add_tidaw(struct itcw *itcw, u8 flags, void *addr, u32 count)
 290 {
 291         if (itcw->num_tidaws >= itcw->max_tidaws)
 292                 return ERR_PTR(-ENOSPC);
 293         return tcw_add_tidaw(itcw->tcw, itcw->num_tidaws++, flags, addr, count);
 294 }
 295 EXPORT_SYMBOL(itcw_add_tidaw);
 296
 297 /**
 298  * itcw_set_data - set data address and tida flag of the itcw
 299  * @itcw: address of the itcw
 300  * @addr: the data address
 301  * @use_tidal: zero of the data address specifies a contiguous block of data,
 302  * non-zero if it specifies a list if tidaws.
 303  *
 304  * Set the input/output data address of the itcw (depending on the value of the
 305  * r-flag and w-flag). If @use_tidal is non-zero, the corresponding tida flag
 306  * is set as well.
 307  */
 308 void itcw_set_data(struct itcw *itcw, void *addr, int use_tidal)
 309 {
 310         tcw_set_data(itcw->tcw, addr, use_tidal);
 311 }
 312 EXPORT_SYMBOL(itcw_set_data);
 313
 314 /**
 315  * itcw_finalize - calculate length and count fields of the itcw
 316  * @itcw: address of the itcw
 317  *
 318  * Calculate tcw input-/output-count and tccbl fields and add a tcat the tccb.
 319  * In case input- or output-tida is used, the tidaw-list must be stored in
 320  * continuous storage (no ttic). The tcal field in the tccb must be
 321  * up-to-date.
 322  */
 323 void itcw_finalize(struct itcw *itcw)
 324 {
 325         tcw_finalize(itcw->tcw, itcw->num_tidaws);
 326 }
 327 EXPORT_SYMBOL(itcw_finalize);