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

   1 /*
   2  *  Functions for assembling 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 "cio.h"
  16
  17 /**
  18  * tcw_get_intrg - return pointer to associated interrogate tcw
  19  * @tcw: pointer to the original tcw
  20  *
  21  * Return a pointer to the interrogate tcw associated with the specified tcw
  22  * or %NULL if there is no associated interrogate tcw.
  23  */
  24 struct tcw *tcw_get_intrg(struct tcw *tcw)
  25 {
  26         return (struct tcw *) ((addr_t) tcw->intrg);
  27 }
  28 EXPORT_SYMBOL(tcw_get_intrg);
  29
  30 /**
  31  * tcw_get_data - return pointer to input/output data associated with tcw
  32  * @tcw: pointer to the tcw
  33  *
  34  * Return the input or output data address specified in the tcw depending
  35  * on whether the r-bit or the w-bit is set. If neither bit is set, return
  36  * %NULL.
  37  */
  38 void *tcw_get_data(struct tcw *tcw)
  39 {
  40         if (tcw->r)
  41                 return (void *) ((addr_t) tcw->input);
  42         if (tcw->w)
  43                 return (void *) ((addr_t) tcw->output);
  44         return NULL;
  45 }
  46 EXPORT_SYMBOL(tcw_get_data);
  47
  48 /**
  49  * tcw_get_tccb - return pointer to tccb associated with tcw
  50  * @tcw: pointer to the tcw
  51  *
  52  * Return pointer to the tccb associated with this tcw.
  53  */
  54 struct tccb *tcw_get_tccb(struct tcw *tcw)
  55 {
  56         return (struct tccb *) ((addr_t) tcw->tccb);
  57 }
  58 EXPORT_SYMBOL(tcw_get_tccb);
  59
  60 /**
  61  * tcw_get_tsb - return pointer to tsb associated with tcw
  62  * @tcw: pointer to the tcw
  63  *
  64  * Return pointer to the tsb associated with this tcw.
  65  */
  66 struct tsb *tcw_get_tsb(struct tcw *tcw)
  67 {
  68         return (struct tsb *) ((addr_t) tcw->tsb);
  69 }
  70 EXPORT_SYMBOL(tcw_get_tsb);
  71
  72 /**
  73  * tcw_init - initialize tcw data structure
  74  * @tcw: pointer to the tcw to be initialized
  75  * @r: initial value of the r-bit
  76  * @w: initial value of the w-bit
  77  *
  78  * Initialize all fields of the specified tcw data structure with zero and
  79  * fill in the format, flags, r and w fields.
  80  */
  81 void tcw_init(struct tcw *tcw, int r, int w)
  82 {
  83         memset(tcw, 0, sizeof(struct tcw));
  84         tcw->format = TCW_FORMAT_DEFAULT;
  85         tcw->flags = TCW_FLAGS_TIDAW_FORMAT(TCW_TIDAW_FORMAT_DEFAULT);
  86         if (r)
  87                 tcw->r = 1;
  88         if (w)
  89                 tcw->w = 1;
  90 }
  91 EXPORT_SYMBOL(tcw_init);
  92
  93 static inline size_t tca_size(struct tccb *tccb)
  94 {
  95         return tccb->tcah.tcal - 12;
  96 }
  97
  98 static u32 calc_dcw_count(struct tccb *tccb)
  99 {
 100         int offset;
 101         struct dcw *dcw;
 102         u32 count = 0;
 103         size_t size;
 104
 105         size = tca_size(tccb);
 106         for (offset = 0; offset < size;) {
 107                 dcw = (struct dcw *) &tccb->tca[offset];
 108                 count += dcw->count;
 109                 if (!(dcw->flags & DCW_FLAGS_CC))
 110                         break;
 111                 offset += sizeof(struct dcw) + ALIGN((int) dcw->cd_count, 4);
 112         }
 113         return count;
 114 }
 115
 116 static u32 calc_cbc_size(struct tidaw *tidaw, int num)
 117 {
 118         int i;
 119         u32 cbc_data;
 120         u32 cbc_count = 0;
 121         u64 data_count = 0;
 122
 123         for (i = 0; i < num; i++) {
 124                 if (tidaw[i].flags & TIDAW_FLAGS_LAST)
 125                         break;
 126                 /* TODO: find out if padding applies to total of data
 127                  * transferred or data transferred by this tidaw. Assumption:
 128                  * applies to total. */
 129                 data_count += tidaw[i].count;
 130                 if (tidaw[i].flags & TIDAW_FLAGS_INSERT_CBC) {
 131                         cbc_data = 4 + ALIGN(data_count, 4) - data_count;
 132                         cbc_count += cbc_data;
 133                         data_count += cbc_data;
 134                 }
 135         }
 136         return cbc_count;
 137 }
 138
 139 /**
 140  * tcw_finalize - finalize tcw length fields and tidaw list
 141  * @tcw: pointer to the tcw
 142  * @num_tidaws: the number of tidaws used to address input/output data or zero
 143  * if no tida is used
 144  *
 145  * Calculate the input-/output-count and tccbl field in the tcw, add a
 146  * tcat the tccb and terminate the data tidaw list if used.
 147  *
 148  * Note: in case input- or output-tida is used, the tidaw-list must be stored
 149  * in contiguous storage (no ttic). The tcal field in the tccb must be
 150  * up-to-date.
 151  */
 152 void tcw_finalize(struct tcw *tcw, int num_tidaws)
 153 {
 154         struct tidaw *tidaw;
 155         struct tccb *tccb;
 156         struct tccb_tcat *tcat;
 157         u32 count;
 158
 159         /* Terminate tidaw list. */
 160         tidaw = tcw_get_data(tcw);
 161         if (num_tidaws > 0)
 162                 tidaw[num_tidaws - 1].flags |= TIDAW_FLAGS_LAST;
 163         /* Add tcat to tccb. */
 164         tccb = tcw_get_tccb(tcw);
 165         tcat = (struct tccb_tcat *) &tccb->tca[tca_size(tccb)];
 166         memset(tcat, 0, sizeof(tcat));
 167         /* Calculate tcw input/output count and tcat transport count. */
 168         count = calc_dcw_count(tccb);
 169         if (tcw->w && (tcw->flags & TCW_FLAGS_OUTPUT_TIDA))
 170                 count += calc_cbc_size(tidaw, num_tidaws);
 171         if (tcw->r)
 172                 tcw->input_count = count;
 173         else if (tcw->w)
 174                 tcw->output_count = count;
 175         tcat->count = ALIGN(count, 4) + 4;
 176         /* Calculate tccbl. */
 177         tcw->tccbl = (sizeof(struct tccb) + tca_size(tccb) +
 178                       sizeof(struct tccb_tcat) - 20) >> 2;
 179 }
 180 EXPORT_SYMBOL(tcw_finalize);
 181
 182 /**
 183  * tcw_set_intrg - set the interrogate tcw address of a tcw
 184  * @tcw: the tcw address
 185  * @intrg_tcw: the address of the interrogate tcw
 186  *
 187  * Set the address of the interrogate tcw in the specified tcw.
 188  */
 189 void tcw_set_intrg(struct tcw *tcw, struct tcw *intrg_tcw)
 190 {
 191         tcw->intrg = (u32) ((addr_t) intrg_tcw);
 192 }
 193 EXPORT_SYMBOL(tcw_set_intrg);
 194
 195 /**
 196  * tcw_set_data - set data address and tida flag of a tcw
 197  * @tcw: the tcw address
 198  * @data: the data address
 199  * @use_tidal: zero of the data address specifies a contiguous block of data,
 200  * non-zero if it specifies a list if tidaws.
 201  *
 202  * Set the input/output data address of a tcw (depending on the value of the
 203  * r-flag and w-flag). If @use_tidal is non-zero, the corresponding tida flag
 204  * is set as well.
 205  */
 206 void tcw_set_data(struct tcw *tcw, void *data, int use_tidal)
 207 {
 208         if (tcw->r) {
 209                 tcw->input = (u64) ((addr_t) data);
 210                 if (use_tidal)
 211                         tcw->flags |= TCW_FLAGS_INPUT_TIDA;
 212         } else if (tcw->w) {
 213                 tcw->output = (u64) ((addr_t) data);
 214                 if (use_tidal)
 215                         tcw->flags |= TCW_FLAGS_OUTPUT_TIDA;
 216         }
 217 }
 218 EXPORT_SYMBOL(tcw_set_data);
 219
 220 /**
 221  * tcw_set_tccb - set tccb address of a tcw
 222  * @tcw: the tcw address
 223  * @tccb: the tccb address
 224  *
 225  * Set the address of the tccb in the specified tcw.
 226  */
 227 void tcw_set_tccb(struct tcw *tcw, struct tccb *tccb)
 228 {
 229         tcw->tccb = (u64) ((addr_t) tccb);
 230 }
 231 EXPORT_SYMBOL(tcw_set_tccb);
 232
 233 /**
 234  * tcw_set_tsb - set tsb address of a tcw
 235  * @tcw: the tcw address
 236  * @tsb: the tsb address
 237  *
 238  * Set the address of the tsb in the specified tcw.
 239  */
 240 void tcw_set_tsb(struct tcw *tcw, struct tsb *tsb)
 241 {
 242         tcw->tsb = (u64) ((addr_t) tsb);
 243 }
 244 EXPORT_SYMBOL(tcw_set_tsb);
 245
 246 /**
 247  * tccb_init - initialize tccb
 248  * @tccb: the tccb address
 249  * @size: the maximum size of the tccb
 250  * @sac: the service-action-code to be user
 251  *
 252  * Initialize the header of the specified tccb by resetting all values to zero
 253  * and filling in defaults for format, sac and initial tcal fields.
 254  */
 255 void tccb_init(struct tccb *tccb, size_t size, u32 sac)
 256 {
 257         memset(tccb, 0, size);
 258         tccb->tcah.format = TCCB_FORMAT_DEFAULT;
 259         tccb->tcah.sac = sac;
 260         tccb->tcah.tcal = 12;
 261 }
 262 EXPORT_SYMBOL(tccb_init);
 263
 264 /**
 265  * tsb_init - initialize tsb
 266  * @tsb: the tsb address
 267  *
 268  * Initialize the specified tsb by resetting all values to zero.
 269  */
 270 void tsb_init(struct tsb *tsb)
 271 {
 272         memset(tsb, 0, sizeof(tsb));
 273 }
 274 EXPORT_SYMBOL(tsb_init);
 275
 276 /**
 277  * tccb_add_dcw - add a dcw to the tccb
 278  * @tccb: the tccb address
 279  * @tccb_size: the maximum tccb size
 280  * @cmd: the dcw command
 281  * @flags: flags for the dcw
 282  * @cd: pointer to control data for this dcw or NULL if none is required
 283  * @cd_count: number of control data bytes for this dcw
 284  * @count: number of data bytes for this dcw
 285  *
 286  * Add a new dcw to the specified tccb by writing the dcw information specified
 287  * by @cmd, @flags, @cd, @cd_count and @count to the tca of the tccb. Return
 288  * a pointer to the newly added dcw on success or -%ENOSPC if the new dcw
 289  * would exceed the available space as defined by @tccb_size.
 290  *
 291  * Note: the tcal field of the tccb header will be updates to reflect added
 292  * content.
 293  */
 294 struct dcw *tccb_add_dcw(struct tccb *tccb, size_t tccb_size, u8 cmd, u8 flags,
 295                          void *cd, u8 cd_count, u32 count)
 296 {
 297         struct dcw *dcw;
 298         int size;
 299         int tca_offset;
 300
 301         /* Check for space. */
 302         tca_offset = tca_size(tccb);
 303         size = ALIGN(sizeof(struct dcw) + cd_count, 4);
 304         if (sizeof(struct tccb_tcah) + tca_offset + size +
 305             sizeof(struct tccb_tcat) > tccb_size)
 306                 return ERR_PTR(-ENOSPC);
 307         /* Add dcw to tca. */
 308         dcw = (struct dcw *) &tccb->tca[tca_offset];
 309         memset(dcw, 0, size);
 310         dcw->cmd = cmd;
 311         dcw->flags = flags;
 312         dcw->count = count;
 313         dcw->cd_count = cd_count;
 314         if (cd)
 315                 memcpy(&dcw->cd[0], cd, cd_count);
 316         tccb->tcah.tcal += size;
 317         return dcw;
 318 }
 319 EXPORT_SYMBOL(tccb_add_dcw);
 320
 321 /**
 322  * tcw_add_tidaw - add a tidaw to a tcw
 323  * @tcw: the tcw address
 324  * @num_tidaws: the current number of tidaws
 325  * @flags: flags for the new tidaw
 326  * @addr: address value for the new tidaw
 327  * @count: count value for the new tidaw
 328  *
 329  * Add a new tidaw to the input/output data tidaw-list of the specified tcw
 330  * (depending on the value of the r-flag and w-flag) and return a pointer to
 331  * the new tidaw.
 332  *
 333  * Note: the tidaw-list is assumed to be contiguous with no ttics. The caller
 334  * must ensure that there is enough space for the new tidaw. The last-tidaw
 335  * flag for the last tidaw in the list will be set by tcw_finalize.
 336  */
 337 struct tidaw *tcw_add_tidaw(struct tcw *tcw, int num_tidaws, u8 flags,
 338                             void *addr, u32 count)
 339 {
 340         struct tidaw *tidaw;
 341
 342         /* Add tidaw to tidaw-list. */
 343         tidaw = ((struct tidaw *) tcw_get_data(tcw)) + num_tidaws;
 344         memset(tidaw, 0, sizeof(struct tidaw));
 345         tidaw->flags = flags;
 346         tidaw->count = count;
 347         tidaw->addr = (u64) ((addr_t) addr);
 348         return tidaw;
 349 }
 350 EXPORT_SYMBOL(tcw_add_tidaw);