tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

[S390] qdio: Split SBAL entry flags

The qdio SBAL entry flag is made-up of four different values that are
independent of one another. Some of the bits are reserved by the
hardware and should not be changed by qdio. Currently all four values
are overwritten since the SBAL entry flag is defined as an u32.

Split the SBAL entry flag into four u8's as defined by the hardware
and don't touch the reserved bits.

Signed-off-by: Jan Glauber <jang@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

authored by

Jan Glauber and committed by
Martin Schwidefsky 3ec90878 9950f8be

+96 -153
+28 -91
arch/s390/include/asm/qdio.h
··· 139 139 struct slibe slibe[QDIO_MAX_BUFFERS_PER_Q]; 140 140 } __attribute__ ((packed, aligned(2048))); 141 141 142 - /** 143 - * struct sbal_flags - storage block address list flags 144 - * @last: last entry 145 - * @cont: contiguous storage 146 - * @frag: fragmentation 147 - */ 148 - struct sbal_flags { 149 - u8 : 1; 150 - u8 last : 1; 151 - u8 cont : 1; 152 - u8 : 1; 153 - u8 frag : 2; 154 - u8 : 2; 155 - } __attribute__ ((packed)); 142 + #define SBAL_EFLAGS_LAST_ENTRY 0x40 143 + #define SBAL_EFLAGS_CONTIGUOUS 0x20 144 + #define SBAL_EFLAGS_FIRST_FRAG 0x04 145 + #define SBAL_EFLAGS_MIDDLE_FRAG 0x08 146 + #define SBAL_EFLAGS_LAST_FRAG 0x0c 147 + #define SBAL_EFLAGS_MASK 0x6f 156 148 157 - #define SBAL_FLAGS_FIRST_FRAG 0x04000000UL 158 - #define SBAL_FLAGS_MIDDLE_FRAG 0x08000000UL 159 - #define SBAL_FLAGS_LAST_FRAG 0x0c000000UL 160 - #define SBAL_FLAGS_LAST_ENTRY 0x40000000UL 161 - #define SBAL_FLAGS_CONTIGUOUS 0x20000000UL 162 - 163 - #define SBAL_FLAGS0_DATA_CONTINUATION 0x20UL 149 + #define SBAL_SFLAGS0_PCI_REQ 0x40 150 + #define SBAL_SFLAGS0_DATA_CONTINUATION 0x20 164 151 165 152 /* Awesome OpenFCP extensions */ 166 - #define SBAL_FLAGS0_TYPE_STATUS 0x00UL 167 - #define SBAL_FLAGS0_TYPE_WRITE 0x08UL 168 - #define SBAL_FLAGS0_TYPE_READ 0x10UL 169 - #define SBAL_FLAGS0_TYPE_WRITE_READ 0x18UL 170 - #define SBAL_FLAGS0_MORE_SBALS 0x04UL 171 - #define SBAL_FLAGS0_COMMAND 0x02UL 172 - #define SBAL_FLAGS0_LAST_SBAL 0x00UL 173 - #define SBAL_FLAGS0_ONLY_SBAL SBAL_FLAGS0_COMMAND 174 - #define SBAL_FLAGS0_MIDDLE_SBAL SBAL_FLAGS0_MORE_SBALS 175 - #define SBAL_FLAGS0_FIRST_SBAL SBAL_FLAGS0_MORE_SBALS | SBAL_FLAGS0_COMMAND 176 - #define SBAL_FLAGS0_PCI 0x40 177 - 178 - /** 179 - * struct sbal_sbalf_0 - sbal flags for sbale 0 180 - * @pci: PCI indicator 181 - * @cont: data continuation 182 - * @sbtype: storage-block type (FCP) 183 - */ 184 - struct sbal_sbalf_0 { 185 - u8 : 1; 186 - u8 pci : 1; 187 - u8 cont : 1; 188 - u8 sbtype : 2; 189 - u8 : 3; 190 - } __attribute__ ((packed)); 191 - 192 - /** 193 - * struct sbal_sbalf_1 - sbal flags for sbale 1 194 - * @key: storage key 195 - */ 196 - struct sbal_sbalf_1 { 197 - u8 : 4; 198 - u8 key : 4; 199 - } __attribute__ ((packed)); 200 - 201 - /** 202 - * struct sbal_sbalf_14 - sbal flags for sbale 14 203 - * @erridx: error index 204 - */ 205 - struct sbal_sbalf_14 { 206 - u8 : 4; 207 - u8 erridx : 4; 208 - } __attribute__ ((packed)); 209 - 210 - /** 211 - * struct sbal_sbalf_15 - sbal flags for sbale 15 212 - * @reason: reason for error state 213 - */ 214 - struct sbal_sbalf_15 { 215 - u8 reason; 216 - } __attribute__ ((packed)); 217 - 218 - /** 219 - * union sbal_sbalf - storage block address list flags 220 - * @i0: sbalf0 221 - * @i1: sbalf1 222 - * @i14: sbalf14 223 - * @i15: sblaf15 224 - * @value: raw value 225 - */ 226 - union sbal_sbalf { 227 - struct sbal_sbalf_0 i0; 228 - struct sbal_sbalf_1 i1; 229 - struct sbal_sbalf_14 i14; 230 - struct sbal_sbalf_15 i15; 231 - u8 value; 232 - }; 153 + #define SBAL_SFLAGS0_TYPE_STATUS 0x00 154 + #define SBAL_SFLAGS0_TYPE_WRITE 0x08 155 + #define SBAL_SFLAGS0_TYPE_READ 0x10 156 + #define SBAL_SFLAGS0_TYPE_WRITE_READ 0x18 157 + #define SBAL_SFLAGS0_MORE_SBALS 0x04 158 + #define SBAL_SFLAGS0_COMMAND 0x02 159 + #define SBAL_SFLAGS0_LAST_SBAL 0x00 160 + #define SBAL_SFLAGS0_ONLY_SBAL SBAL_SFLAGS0_COMMAND 161 + #define SBAL_SFLAGS0_MIDDLE_SBAL SBAL_SFLAGS0_MORE_SBALS 162 + #define SBAL_SFLAGS0_FIRST_SBAL (SBAL_SFLAGS0_MORE_SBALS | SBAL_SFLAGS0_COMMAND) 233 163 234 164 /** 235 165 * struct qdio_buffer_element - SBAL entry 236 - * @flags: flags 166 + * @eflags: SBAL entry flags 167 + * @scount: SBAL count 168 + * @sflags: whole SBAL flags 237 169 * @length: length 238 170 * @addr: address 239 171 */ 240 172 struct qdio_buffer_element { 241 - u32 flags; 173 + u8 eflags; 174 + /* private: */ 175 + u8 res1; 176 + /* public: */ 177 + u8 scount; 178 + u8 sflags; 242 179 u32 length; 243 180 #ifdef CONFIG_32BIT 244 181 /* private: */ 245 - void *reserved; 182 + void *res2; 246 183 /* public: */ 247 184 #endif 248 185 void *addr;
+3 -3
drivers/s390/cio/qdio_main.c
··· 416 416 417 417 /* special handling for no target buffer empty */ 418 418 if ((!q->is_input_q && 419 - (q->sbal[q->first_to_check]->element[15].flags & 0xff) == 0x10)) { 419 + (q->sbal[q->first_to_check]->element[15].sflags) == 0x10)) { 420 420 qperf_inc(q, target_full); 421 421 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "OUTFULL FTC:%02x", 422 422 q->first_to_check); ··· 427 427 DBF_ERROR((q->is_input_q) ? "IN:%2d" : "OUT:%2d", q->nr); 428 428 DBF_ERROR("FTC:%3d C:%3d", q->first_to_check, count); 429 429 DBF_ERROR("F14:%2x F15:%2x", 430 - q->sbal[q->first_to_check]->element[14].flags & 0xff, 431 - q->sbal[q->first_to_check]->element[15].flags & 0xff); 430 + q->sbal[q->first_to_check]->element[14].sflags, 431 + q->sbal[q->first_to_check]->element[15].sflags); 432 432 433 433 /* 434 434 * Interrupts may be avoided as long as the error is present
+1 -1
drivers/s390/net/qeth_core.h
··· 361 361 362 362 static inline int qeth_is_last_sbale(struct qdio_buffer_element *sbale) 363 363 { 364 - return (sbale->flags & SBAL_FLAGS_LAST_ENTRY); 364 + return (sbale->eflags & SBAL_EFLAGS_LAST_ENTRY); 365 365 } 366 366 367 367 enum qeth_qdio_buffer_states {
+30 -27
drivers/s390/net/qeth_core_main.c
··· 890 890 struct sk_buff *skb; 891 891 892 892 /* is PCI flag set on buffer? */ 893 - if (buf->buffer->element[0].flags & 0x40) 893 + if (buf->buffer->element[0].sflags & SBAL_SFLAGS0_PCI_REQ) 894 894 atomic_dec(&queue->set_pci_flags_count); 895 895 896 896 skb = skb_dequeue(&buf->skb_list); ··· 906 906 buf->is_header[i] = 0; 907 907 buf->buffer->element[i].length = 0; 908 908 buf->buffer->element[i].addr = NULL; 909 - buf->buffer->element[i].flags = 0; 909 + buf->buffer->element[i].eflags = 0; 910 + buf->buffer->element[i].sflags = 0; 910 911 } 911 - buf->buffer->element[15].flags = 0; 912 + buf->buffer->element[15].eflags = 0; 913 + buf->buffer->element[15].sflags = 0; 912 914 buf->next_element_to_fill = 0; 913 915 atomic_set(&buf->state, QETH_QDIO_BUF_EMPTY); 914 916 } ··· 2370 2368 buf->buffer->element[i].length = PAGE_SIZE; 2371 2369 buf->buffer->element[i].addr = pool_entry->elements[i]; 2372 2370 if (i == QETH_MAX_BUFFER_ELEMENTS(card) - 1) 2373 - buf->buffer->element[i].flags = SBAL_FLAGS_LAST_ENTRY; 2371 + buf->buffer->element[i].eflags = SBAL_EFLAGS_LAST_ENTRY; 2374 2372 else 2375 - buf->buffer->element[i].flags = 0; 2373 + buf->buffer->element[i].eflags = 0; 2374 + buf->buffer->element[i].sflags = 0; 2376 2375 } 2377 2376 return 0; 2378 2377 } ··· 2721 2718 if (qdio_error) { 2722 2719 QETH_CARD_TEXT(card, 2, dbftext); 2723 2720 QETH_CARD_TEXT_(card, 2, " F15=%02X", 2724 - buf->element[15].flags & 0xff); 2721 + buf->element[15].sflags); 2725 2722 QETH_CARD_TEXT_(card, 2, " F14=%02X", 2726 - buf->element[14].flags & 0xff); 2723 + buf->element[14].sflags); 2727 2724 QETH_CARD_TEXT_(card, 2, " qerr=%X", qdio_error); 2728 - if ((buf->element[15].flags & 0xff) == 0x12) { 2725 + if ((buf->element[15].sflags) == 0x12) { 2729 2726 card->stats.rx_dropped++; 2730 2727 return 0; 2731 2728 } else ··· 2801 2798 static int qeth_handle_send_error(struct qeth_card *card, 2802 2799 struct qeth_qdio_out_buffer *buffer, unsigned int qdio_err) 2803 2800 { 2804 - int sbalf15 = buffer->buffer->element[15].flags & 0xff; 2801 + int sbalf15 = buffer->buffer->element[15].sflags; 2805 2802 2806 2803 QETH_CARD_TEXT(card, 6, "hdsnderr"); 2807 2804 if (card->info.type == QETH_CARD_TYPE_IQD) { ··· 2910 2907 2911 2908 for (i = index; i < index + count; ++i) { 2912 2909 buf = &queue->bufs[i % QDIO_MAX_BUFFERS_PER_Q]; 2913 - buf->buffer->element[buf->next_element_to_fill - 1].flags |= 2914 - SBAL_FLAGS_LAST_ENTRY; 2910 + buf->buffer->element[buf->next_element_to_fill - 1].eflags |= 2911 + SBAL_EFLAGS_LAST_ENTRY; 2915 2912 2916 2913 if (queue->card->info.type == QETH_CARD_TYPE_IQD) 2917 2914 continue; ··· 2924 2921 /* it's likely that we'll go to packing 2925 2922 * mode soon */ 2926 2923 atomic_inc(&queue->set_pci_flags_count); 2927 - buf->buffer->element[0].flags |= 0x40; 2924 + buf->buffer->element[0].sflags |= SBAL_SFLAGS0_PCI_REQ; 2928 2925 } 2929 2926 } else { 2930 2927 if (!atomic_read(&queue->set_pci_flags_count)) { ··· 2937 2934 * further send was requested by the stack 2938 2935 */ 2939 2936 atomic_inc(&queue->set_pci_flags_count); 2940 - buf->buffer->element[0].flags |= 0x40; 2937 + buf->buffer->element[0].sflags |= SBAL_SFLAGS0_PCI_REQ; 2941 2938 } 2942 2939 } 2943 2940 } ··· 3183 3180 if (!length) { 3184 3181 if (first_lap) 3185 3182 if (skb_shinfo(skb)->nr_frags) 3186 - buffer->element[element].flags = 3187 - SBAL_FLAGS_FIRST_FRAG; 3183 + buffer->element[element].eflags = 3184 + SBAL_EFLAGS_FIRST_FRAG; 3188 3185 else 3189 - buffer->element[element].flags = 0; 3186 + buffer->element[element].eflags = 0; 3190 3187 else 3191 - buffer->element[element].flags = 3192 - SBAL_FLAGS_MIDDLE_FRAG; 3188 + buffer->element[element].eflags = 3189 + SBAL_EFLAGS_MIDDLE_FRAG; 3193 3190 } else { 3194 3191 if (first_lap) 3195 - buffer->element[element].flags = 3196 - SBAL_FLAGS_FIRST_FRAG; 3192 + buffer->element[element].eflags = 3193 + SBAL_EFLAGS_FIRST_FRAG; 3197 3194 else 3198 - buffer->element[element].flags = 3199 - SBAL_FLAGS_MIDDLE_FRAG; 3195 + buffer->element[element].eflags = 3196 + SBAL_EFLAGS_MIDDLE_FRAG; 3200 3197 } 3201 3198 data += length_here; 3202 3199 element++; ··· 3208 3205 buffer->element[element].addr = (char *)page_to_phys(frag->page) 3209 3206 + frag->page_offset; 3210 3207 buffer->element[element].length = frag->size; 3211 - buffer->element[element].flags = SBAL_FLAGS_MIDDLE_FRAG; 3208 + buffer->element[element].eflags = SBAL_EFLAGS_MIDDLE_FRAG; 3212 3209 element++; 3213 3210 } 3214 3211 3215 - if (buffer->element[element - 1].flags) 3216 - buffer->element[element - 1].flags = SBAL_FLAGS_LAST_FRAG; 3212 + if (buffer->element[element - 1].eflags) 3213 + buffer->element[element - 1].eflags = SBAL_EFLAGS_LAST_FRAG; 3217 3214 *next_element_to_fill = element; 3218 3215 } 3219 3216 ··· 3237 3234 /*fill first buffer entry only with header information */ 3238 3235 buffer->element[element].addr = skb->data; 3239 3236 buffer->element[element].length = hdr_len; 3240 - buffer->element[element].flags = SBAL_FLAGS_FIRST_FRAG; 3237 + buffer->element[element].eflags = SBAL_EFLAGS_FIRST_FRAG; 3241 3238 buf->next_element_to_fill++; 3242 3239 skb->data += hdr_len; 3243 3240 skb->len -= hdr_len; ··· 3249 3246 buffer->element[element].addr = hdr; 3250 3247 buffer->element[element].length = sizeof(struct qeth_hdr) + 3251 3248 hd_len; 3252 - buffer->element[element].flags = SBAL_FLAGS_FIRST_FRAG; 3249 + buffer->element[element].eflags = SBAL_EFLAGS_FIRST_FRAG; 3253 3250 buf->is_header[element] = 1; 3254 3251 buf->next_element_to_fill++; 3255 3252 }
+23 -22
drivers/s390/scsi/zfcp_fsf.c
··· 640 640 } 641 641 642 642 static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio, 643 - u32 fsf_cmd, u32 sbtype, 643 + u32 fsf_cmd, u8 sbtype, 644 644 mempool_t *pool) 645 645 { 646 646 struct zfcp_adapter *adapter = qdio->adapter; ··· 841 841 if (zfcp_qdio_sbal_get(qdio)) 842 842 goto out; 843 843 req = zfcp_fsf_req_create(qdio, FSF_QTCB_ABORT_FCP_CMND, 844 - SBAL_FLAGS0_TYPE_READ, 844 + SBAL_SFLAGS0_TYPE_READ, 845 845 qdio->adapter->pool.scsi_abort); 846 846 if (IS_ERR(req)) { 847 847 req = NULL; ··· 1012 1012 goto out; 1013 1013 1014 1014 req = zfcp_fsf_req_create(qdio, FSF_QTCB_SEND_GENERIC, 1015 - SBAL_FLAGS0_TYPE_WRITE_READ, pool); 1015 + SBAL_SFLAGS0_TYPE_WRITE_READ, pool); 1016 1016 1017 1017 if (IS_ERR(req)) { 1018 1018 ret = PTR_ERR(req); ··· 1110 1110 goto out; 1111 1111 1112 1112 req = zfcp_fsf_req_create(qdio, FSF_QTCB_SEND_ELS, 1113 - SBAL_FLAGS0_TYPE_WRITE_READ, NULL); 1113 + SBAL_SFLAGS0_TYPE_WRITE_READ, NULL); 1114 1114 1115 1115 if (IS_ERR(req)) { 1116 1116 ret = PTR_ERR(req); ··· 1156 1156 goto out; 1157 1157 1158 1158 req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_CONFIG_DATA, 1159 - SBAL_FLAGS0_TYPE_READ, 1159 + SBAL_SFLAGS0_TYPE_READ, 1160 1160 qdio->adapter->pool.erp_req); 1161 1161 1162 1162 if (IS_ERR(req)) { ··· 1198 1198 goto out_unlock; 1199 1199 1200 1200 req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_CONFIG_DATA, 1201 - SBAL_FLAGS0_TYPE_READ, NULL); 1201 + SBAL_SFLAGS0_TYPE_READ, NULL); 1202 1202 1203 1203 if (IS_ERR(req)) { 1204 1204 retval = PTR_ERR(req); ··· 1250 1250 goto out; 1251 1251 1252 1252 req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_PORT_DATA, 1253 - SBAL_FLAGS0_TYPE_READ, 1253 + SBAL_SFLAGS0_TYPE_READ, 1254 1254 qdio->adapter->pool.erp_req); 1255 1255 1256 1256 if (IS_ERR(req)) { ··· 1296 1296 goto out_unlock; 1297 1297 1298 1298 req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_PORT_DATA, 1299 - SBAL_FLAGS0_TYPE_READ, NULL); 1299 + SBAL_SFLAGS0_TYPE_READ, NULL); 1300 1300 1301 1301 if (IS_ERR(req)) { 1302 1302 retval = PTR_ERR(req); ··· 1412 1412 goto out; 1413 1413 1414 1414 req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_PORT_WITH_DID, 1415 - SBAL_FLAGS0_TYPE_READ, 1415 + SBAL_SFLAGS0_TYPE_READ, 1416 1416 qdio->adapter->pool.erp_req); 1417 1417 1418 1418 if (IS_ERR(req)) { ··· 1478 1478 goto out; 1479 1479 1480 1480 req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PORT, 1481 - SBAL_FLAGS0_TYPE_READ, 1481 + SBAL_SFLAGS0_TYPE_READ, 1482 1482 qdio->adapter->pool.erp_req); 1483 1483 1484 1484 if (IS_ERR(req)) { ··· 1553 1553 goto out; 1554 1554 1555 1555 req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_PORT_WITH_DID, 1556 - SBAL_FLAGS0_TYPE_READ, 1556 + SBAL_SFLAGS0_TYPE_READ, 1557 1557 qdio->adapter->pool.erp_req); 1558 1558 1559 1559 if (IS_ERR(req)) { ··· 1606 1606 goto out; 1607 1607 1608 1608 req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PORT, 1609 - SBAL_FLAGS0_TYPE_READ, 1609 + SBAL_SFLAGS0_TYPE_READ, 1610 1610 qdio->adapter->pool.erp_req); 1611 1611 1612 1612 if (IS_ERR(req)) { ··· 1698 1698 goto out; 1699 1699 1700 1700 req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PHYSICAL_PORT, 1701 - SBAL_FLAGS0_TYPE_READ, 1701 + SBAL_SFLAGS0_TYPE_READ, 1702 1702 qdio->adapter->pool.erp_req); 1703 1703 1704 1704 if (IS_ERR(req)) { ··· 1812 1812 goto out; 1813 1813 1814 1814 req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_LUN, 1815 - SBAL_FLAGS0_TYPE_READ, 1815 + SBAL_SFLAGS0_TYPE_READ, 1816 1816 adapter->pool.erp_req); 1817 1817 1818 1818 if (IS_ERR(req)) { ··· 1901 1901 goto out; 1902 1902 1903 1903 req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_LUN, 1904 - SBAL_FLAGS0_TYPE_READ, 1904 + SBAL_SFLAGS0_TYPE_READ, 1905 1905 qdio->adapter->pool.erp_req); 1906 1906 1907 1907 if (IS_ERR(req)) { ··· 2161 2161 { 2162 2162 struct zfcp_fsf_req *req; 2163 2163 struct fcp_cmnd *fcp_cmnd; 2164 - unsigned int sbtype = SBAL_FLAGS0_TYPE_READ; 2164 + u8 sbtype = SBAL_SFLAGS0_TYPE_READ; 2165 2165 int real_bytes, retval = -EIO, dix_bytes = 0; 2166 2166 struct scsi_device *sdev = scsi_cmnd->device; 2167 2167 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); ··· 2181 2181 } 2182 2182 2183 2183 if (scsi_cmnd->sc_data_direction == DMA_TO_DEVICE) 2184 - sbtype = SBAL_FLAGS0_TYPE_WRITE; 2184 + sbtype = SBAL_SFLAGS0_TYPE_WRITE; 2185 2185 2186 2186 req = zfcp_fsf_req_create(qdio, FSF_QTCB_FCP_CMND, 2187 2187 sbtype, adapter->pool.scsi_req); ··· 2280 2280 goto out; 2281 2281 2282 2282 req = zfcp_fsf_req_create(qdio, FSF_QTCB_FCP_CMND, 2283 - SBAL_FLAGS0_TYPE_WRITE, 2283 + SBAL_SFLAGS0_TYPE_WRITE, 2284 2284 qdio->adapter->pool.scsi_req); 2285 2285 2286 2286 if (IS_ERR(req)) { ··· 2328 2328 struct zfcp_qdio *qdio = adapter->qdio; 2329 2329 struct zfcp_fsf_req *req = NULL; 2330 2330 struct fsf_qtcb_bottom_support *bottom; 2331 - int direction, retval = -EIO, bytes; 2331 + int retval = -EIO, bytes; 2332 + u8 direction; 2332 2333 2333 2334 if (!(adapter->adapter_features & FSF_FEATURE_CFDC)) 2334 2335 return ERR_PTR(-EOPNOTSUPP); 2335 2336 2336 2337 switch (fsf_cfdc->command) { 2337 2338 case FSF_QTCB_DOWNLOAD_CONTROL_FILE: 2338 - direction = SBAL_FLAGS0_TYPE_WRITE; 2339 + direction = SBAL_SFLAGS0_TYPE_WRITE; 2339 2340 break; 2340 2341 case FSF_QTCB_UPLOAD_CONTROL_FILE: 2341 - direction = SBAL_FLAGS0_TYPE_READ; 2342 + direction = SBAL_SFLAGS0_TYPE_READ; 2342 2343 break; 2343 2344 default: 2344 2345 return ERR_PTR(-EINVAL); ··· 2414 2413 fsf_req->qdio_req.sbal_response = sbal_idx; 2415 2414 zfcp_fsf_req_complete(fsf_req); 2416 2415 2417 - if (likely(sbale->flags & SBAL_FLAGS_LAST_ENTRY)) 2416 + if (likely(sbale->eflags & SBAL_EFLAGS_LAST_ENTRY)) 2418 2417 break; 2419 2418 } 2420 2419 }
+6 -5
drivers/s390/scsi/zfcp_qdio.c
··· 124 124 125 125 /* set last entry flag in current SBALE of current SBAL */ 126 126 sbale = zfcp_qdio_sbale_curr(qdio, q_req); 127 - sbale->flags |= SBAL_FLAGS_LAST_ENTRY; 127 + sbale->eflags |= SBAL_EFLAGS_LAST_ENTRY; 128 128 129 129 /* don't exceed last allowed SBAL */ 130 130 if (q_req->sbal_last == q_req->sbal_limit) ··· 132 132 133 133 /* set chaining flag in first SBALE of current SBAL */ 134 134 sbale = zfcp_qdio_sbale_req(qdio, q_req); 135 - sbale->flags |= SBAL_FLAGS0_MORE_SBALS; 135 + sbale->sflags |= SBAL_SFLAGS0_MORE_SBALS; 136 136 137 137 /* calculate index of next SBAL */ 138 138 q_req->sbal_last++; ··· 147 147 148 148 /* set storage-block type for new SBAL */ 149 149 sbale = zfcp_qdio_sbale_curr(qdio, q_req); 150 - sbale->flags |= q_req->sbtype; 150 + sbale->sflags |= q_req->sbtype; 151 151 152 152 return sbale; 153 153 } ··· 177 177 178 178 /* set storage-block type for this request */ 179 179 sbale = zfcp_qdio_sbale_req(qdio, q_req); 180 - sbale->flags |= q_req->sbtype; 180 + sbale->sflags |= q_req->sbtype; 181 181 182 182 for (; sg; sg = sg_next(sg)) { 183 183 sbale = zfcp_qdio_sbale_next(qdio, q_req); ··· 384 384 for (cc = 0; cc < QDIO_MAX_BUFFERS_PER_Q; cc++) { 385 385 sbale = &(qdio->res_q[cc]->element[0]); 386 386 sbale->length = 0; 387 - sbale->flags = SBAL_FLAGS_LAST_ENTRY; 387 + sbale->eflags = SBAL_EFLAGS_LAST_ENTRY; 388 + sbale->sflags = 0; 388 389 sbale->addr = NULL; 389 390 } 390 391
+5 -4
drivers/s390/scsi/zfcp_qdio.h
··· 67 67 * @qdio_outb_usage: usage of outbound queue 68 68 */ 69 69 struct zfcp_qdio_req { 70 - u32 sbtype; 70 + u8 sbtype; 71 71 u8 sbal_number; 72 72 u8 sbal_first; 73 73 u8 sbal_last; ··· 116 116 */ 117 117 static inline 118 118 void zfcp_qdio_req_init(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req, 119 - unsigned long req_id, u32 sbtype, void *data, u32 len) 119 + unsigned long req_id, u8 sbtype, void *data, u32 len) 120 120 { 121 121 struct qdio_buffer_element *sbale; 122 122 int count = min(atomic_read(&qdio->req_q_free), ··· 131 131 132 132 sbale = zfcp_qdio_sbale_req(qdio, q_req); 133 133 sbale->addr = (void *) req_id; 134 - sbale->flags = SBAL_FLAGS0_COMMAND | sbtype; 134 + sbale->eflags = 0; 135 + sbale->sflags = SBAL_SFLAGS0_COMMAND | sbtype; 135 136 136 137 if (unlikely(!data)) 137 138 return; ··· 174 173 struct qdio_buffer_element *sbale; 175 174 176 175 sbale = zfcp_qdio_sbale_curr(qdio, q_req); 177 - sbale->flags |= SBAL_FLAGS_LAST_ENTRY; 176 + sbale->eflags |= SBAL_EFLAGS_LAST_ENTRY; 178 177 } 179 178 180 179 /**