Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * S/390 common I/O routines -- channel subsystem call |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 4 | * Copyright IBM Corp. 1999,2012 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | * Author(s): Ingo Adlung (adlung@de.ibm.com) |
Cornelia Huck | 4ce3b30 | 2006-01-14 13:21:04 -0800 | [diff] [blame] | 6 | * Cornelia Huck (cornelia.huck@de.ibm.com) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | * Arnd Bergmann (arndb@de.ibm.com) |
| 8 | */ |
| 9 | |
Michael Ernst | e6d5a42 | 2008-12-25 13:39:36 +0100 | [diff] [blame] | 10 | #define KMSG_COMPONENT "cio" |
| 11 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt |
| 12 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | #include <linux/slab.h> |
| 15 | #include <linux/init.h> |
| 16 | #include <linux/device.h> |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 17 | #include <linux/pci.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | |
| 19 | #include <asm/cio.h> |
Peter Oberparleiter | e5854a5 | 2007-04-27 16:01:31 +0200 | [diff] [blame] | 20 | #include <asm/chpid.h> |
Cornelia Huck | 9d92a7e | 2008-07-14 09:59:05 +0200 | [diff] [blame] | 21 | #include <asm/chsc.h> |
Heiko Carstens | f5daba1 | 2009-03-26 15:24:01 +0100 | [diff] [blame] | 22 | #include <asm/crw.h> |
Sebastian Ott | ca4ba15 | 2013-06-05 18:59:22 +0200 | [diff] [blame] | 23 | #include <asm/isc.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | |
| 25 | #include "css.h" |
| 26 | #include "cio.h" |
| 27 | #include "cio_debug.h" |
| 28 | #include "ioasm.h" |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 29 | #include "chp.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | #include "chsc.h" |
| 31 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | static void *sei_page; |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 33 | static void *chsc_page; |
| 34 | static DEFINE_SPINLOCK(chsc_page_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | |
Cornelia Huck | dae3984 | 2008-07-17 17:16:47 +0200 | [diff] [blame] | 36 | /** |
| 37 | * chsc_error_from_response() - convert a chsc response to an error |
| 38 | * @response: chsc response code |
| 39 | * |
| 40 | * Returns an appropriate Linux error code for @response. |
| 41 | */ |
| 42 | int chsc_error_from_response(int response) |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 43 | { |
| 44 | switch (response) { |
| 45 | case 0x0001: |
| 46 | return 0; |
| 47 | case 0x0002: |
| 48 | case 0x0003: |
| 49 | case 0x0006: |
| 50 | case 0x0007: |
| 51 | case 0x0008: |
| 52 | case 0x000a: |
Michael Ernst | fd0457a | 2010-08-09 18:12:50 +0200 | [diff] [blame] | 53 | case 0x0104: |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 54 | return -EINVAL; |
| 55 | case 0x0004: |
| 56 | return -EOPNOTSUPP; |
Sebastian Ott | 184b08a | 2012-08-28 16:45:42 +0200 | [diff] [blame] | 57 | case 0x000b: |
Eugene Crosser | 1c59a86 | 2013-04-24 12:00:23 +0200 | [diff] [blame] | 58 | case 0x0107: /* "Channel busy" for the op 0x003d */ |
Sebastian Ott | 184b08a | 2012-08-28 16:45:42 +0200 | [diff] [blame] | 59 | return -EBUSY; |
| 60 | case 0x0100: |
| 61 | case 0x0102: |
| 62 | return -ENOMEM; |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 63 | default: |
| 64 | return -EIO; |
| 65 | } |
| 66 | } |
Cornelia Huck | dae3984 | 2008-07-17 17:16:47 +0200 | [diff] [blame] | 67 | EXPORT_SYMBOL_GPL(chsc_error_from_response); |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 68 | |
Peter Oberparleiter | 7ad6a24 | 2007-04-27 16:01:35 +0200 | [diff] [blame] | 69 | struct chsc_ssd_area { |
| 70 | struct chsc_header request; |
| 71 | u16 :10; |
| 72 | u16 ssid:2; |
| 73 | u16 :4; |
| 74 | u16 f_sch; /* first subchannel */ |
| 75 | u16 :16; |
| 76 | u16 l_sch; /* last subchannel */ |
| 77 | u32 :32; |
| 78 | struct chsc_header response; |
| 79 | u32 :32; |
| 80 | u8 sch_valid : 1; |
| 81 | u8 dev_valid : 1; |
| 82 | u8 st : 3; /* subchannel type */ |
| 83 | u8 zeroes : 3; |
| 84 | u8 unit_addr; /* unit address */ |
| 85 | u16 devno; /* device number */ |
| 86 | u8 path_mask; |
| 87 | u8 fla_valid_mask; |
| 88 | u16 sch; /* subchannel */ |
| 89 | u8 chpid[8]; /* chpids 0-7 */ |
| 90 | u16 fla[8]; /* full link addresses 0-7 */ |
| 91 | } __attribute__ ((packed)); |
| 92 | |
| 93 | int chsc_get_ssd_info(struct subchannel_id schid, struct chsc_ssd_info *ssd) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | { |
Peter Oberparleiter | 7ad6a24 | 2007-04-27 16:01:35 +0200 | [diff] [blame] | 95 | struct chsc_ssd_area *ssd_area; |
| 96 | int ccode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | int ret; |
Peter Oberparleiter | 7ad6a24 | 2007-04-27 16:01:35 +0200 | [diff] [blame] | 98 | int i; |
| 99 | int mask; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 101 | spin_lock_irq(&chsc_page_lock); |
| 102 | memset(chsc_page, 0, PAGE_SIZE); |
| 103 | ssd_area = chsc_page; |
Peter Oberparleiter | 7ad6a24 | 2007-04-27 16:01:35 +0200 | [diff] [blame] | 104 | ssd_area->request.length = 0x0010; |
| 105 | ssd_area->request.code = 0x0004; |
| 106 | ssd_area->ssid = schid.ssid; |
| 107 | ssd_area->f_sch = schid.sch_no; |
| 108 | ssd_area->l_sch = schid.sch_no; |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 109 | |
Peter Oberparleiter | 7ad6a24 | 2007-04-27 16:01:35 +0200 | [diff] [blame] | 110 | ccode = chsc(ssd_area); |
| 111 | /* Check response. */ |
| 112 | if (ccode > 0) { |
| 113 | ret = (ccode == 3) ? -ENODEV : -EBUSY; |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 114 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | } |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 116 | ret = chsc_error_from_response(ssd_area->response.code); |
| 117 | if (ret != 0) { |
Peter Oberparleiter | 7ad6a24 | 2007-04-27 16:01:35 +0200 | [diff] [blame] | 118 | CIO_MSG_EVENT(2, "chsc: ssd failed for 0.%x.%04x (rc=%04x)\n", |
| 119 | schid.ssid, schid.sch_no, |
| 120 | ssd_area->response.code); |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 121 | goto out; |
Peter Oberparleiter | 7ad6a24 | 2007-04-27 16:01:35 +0200 | [diff] [blame] | 122 | } |
| 123 | if (!ssd_area->sch_valid) { |
| 124 | ret = -ENODEV; |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 125 | goto out; |
Peter Oberparleiter | 7ad6a24 | 2007-04-27 16:01:35 +0200 | [diff] [blame] | 126 | } |
| 127 | /* Copy data */ |
| 128 | ret = 0; |
| 129 | memset(ssd, 0, sizeof(struct chsc_ssd_info)); |
Cornelia Huck | b279a4f | 2008-01-26 14:10:45 +0100 | [diff] [blame] | 130 | if ((ssd_area->st != SUBCHANNEL_TYPE_IO) && |
| 131 | (ssd_area->st != SUBCHANNEL_TYPE_MSG)) |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 132 | goto out; |
Peter Oberparleiter | 7ad6a24 | 2007-04-27 16:01:35 +0200 | [diff] [blame] | 133 | ssd->path_mask = ssd_area->path_mask; |
| 134 | ssd->fla_valid_mask = ssd_area->fla_valid_mask; |
| 135 | for (i = 0; i < 8; i++) { |
| 136 | mask = 0x80 >> i; |
| 137 | if (ssd_area->path_mask & mask) { |
| 138 | chp_id_init(&ssd->chpid[i]); |
| 139 | ssd->chpid[i].id = ssd_area->chpid[i]; |
| 140 | } |
| 141 | if (ssd_area->fla_valid_mask & mask) |
| 142 | ssd->fla[i] = ssd_area->fla[i]; |
| 143 | } |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 144 | out: |
| 145 | spin_unlock_irq(&chsc_page_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | return ret; |
| 147 | } |
| 148 | |
Sebastian Ott | da5b6cb | 2013-06-05 18:58:35 +0200 | [diff] [blame] | 149 | /** |
| 150 | * chsc_ssqd() - store subchannel QDIO data (SSQD) |
| 151 | * @schid: id of the subchannel on which SSQD is performed |
| 152 | * @ssqd: request and response block for SSQD |
| 153 | * |
| 154 | * Returns 0 on success. |
| 155 | */ |
| 156 | int chsc_ssqd(struct subchannel_id schid, struct chsc_ssqd_area *ssqd) |
| 157 | { |
| 158 | memset(ssqd, 0, sizeof(*ssqd)); |
| 159 | ssqd->request.length = 0x0010; |
| 160 | ssqd->request.code = 0x0024; |
| 161 | ssqd->first_sch = schid.sch_no; |
| 162 | ssqd->last_sch = schid.sch_no; |
| 163 | ssqd->ssid = schid.ssid; |
| 164 | |
| 165 | if (chsc(ssqd)) |
| 166 | return -EIO; |
| 167 | |
| 168 | return chsc_error_from_response(ssqd->response.code); |
| 169 | } |
| 170 | EXPORT_SYMBOL_GPL(chsc_ssqd); |
| 171 | |
Sebastian Ott | ca4ba15 | 2013-06-05 18:59:22 +0200 | [diff] [blame] | 172 | /** |
| 173 | * chsc_sadc() - set adapter device controls (SADC) |
| 174 | * @schid: id of the subchannel on which SADC is performed |
| 175 | * @scssc: request and response block for SADC |
| 176 | * @summary_indicator_addr: summary indicator address |
| 177 | * @subchannel_indicator_addr: subchannel indicator address |
| 178 | * |
| 179 | * Returns 0 on success. |
| 180 | */ |
| 181 | int chsc_sadc(struct subchannel_id schid, struct chsc_scssc_area *scssc, |
| 182 | u64 summary_indicator_addr, u64 subchannel_indicator_addr) |
| 183 | { |
| 184 | memset(scssc, 0, sizeof(*scssc)); |
| 185 | scssc->request.length = 0x0fe0; |
| 186 | scssc->request.code = 0x0021; |
| 187 | scssc->operation_code = 0; |
| 188 | |
| 189 | scssc->summary_indicator_addr = summary_indicator_addr; |
| 190 | scssc->subchannel_indicator_addr = subchannel_indicator_addr; |
| 191 | |
| 192 | scssc->ks = PAGE_DEFAULT_KEY >> 4; |
| 193 | scssc->kc = PAGE_DEFAULT_KEY >> 4; |
| 194 | scssc->isc = QDIO_AIRQ_ISC; |
| 195 | scssc->schid = schid; |
| 196 | |
| 197 | /* enable the time delay disablement facility */ |
| 198 | if (css_general_characteristics.aif_tdd) |
| 199 | scssc->word_with_d_bit = 0x10000000; |
| 200 | |
| 201 | if (chsc(scssc)) |
| 202 | return -EIO; |
| 203 | |
| 204 | return chsc_error_from_response(scssc->response.code); |
| 205 | } |
| 206 | EXPORT_SYMBOL_GPL(chsc_sadc); |
| 207 | |
Peter Oberparleiter | e82a156 | 2008-01-26 14:10:48 +0100 | [diff] [blame] | 208 | static int s390_subchannel_remove_chpid(struct subchannel *sch, void *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 209 | { |
Cornelia Huck | 2ec2298 | 2006-12-08 15:54:26 +0100 | [diff] [blame] | 210 | spin_lock_irq(sch->lock); |
Cornelia Huck | c820de3 | 2008-07-14 09:58:45 +0200 | [diff] [blame] | 211 | if (sch->driver && sch->driver->chp_event) |
| 212 | if (sch->driver->chp_event(sch, data, CHP_OFFLINE) != 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 213 | goto out_unreg; |
Cornelia Huck | 2ec2298 | 2006-12-08 15:54:26 +0100 | [diff] [blame] | 214 | spin_unlock_irq(sch->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | return 0; |
Stefan Bader | 387b734 | 2007-04-27 16:01:33 +0200 | [diff] [blame] | 216 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | out_unreg: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | sch->lpm = 0; |
Stefan Bader | 387b734 | 2007-04-27 16:01:33 +0200 | [diff] [blame] | 219 | spin_unlock_irq(sch->lock); |
Peter Oberparleiter | 83b3370 | 2007-04-27 16:01:34 +0200 | [diff] [blame] | 220 | css_schedule_eval(sch->schid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | return 0; |
| 222 | } |
| 223 | |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 224 | void chsc_chp_offline(struct chp_id chpid) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | { |
| 226 | char dbf_txt[15]; |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 227 | struct chp_link link; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 229 | sprintf(dbf_txt, "chpr%x.%02x", chpid.cssid, chpid.id); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | CIO_TRACE_EVENT(2, dbf_txt); |
| 231 | |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 232 | if (chp_get_status(chpid) <= 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | return; |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 234 | memset(&link, 0, sizeof(struct chp_link)); |
| 235 | link.chpid = chpid; |
Cornelia Huck | 22806dc | 2008-04-17 07:45:59 +0200 | [diff] [blame] | 236 | /* Wait until previous actions have settled. */ |
| 237 | css_wait_for_slow_path(); |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 238 | for_each_subchannel_staged(s390_subchannel_remove_chpid, NULL, &link); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 239 | } |
| 240 | |
Peter Oberparleiter | e82a156 | 2008-01-26 14:10:48 +0100 | [diff] [blame] | 241 | static int __s390_process_res_acc(struct subchannel *sch, void *data) |
Cornelia Huck | f97a56f | 2006-01-06 00:19:22 -0800 | [diff] [blame] | 242 | { |
Cornelia Huck | 2ec2298 | 2006-12-08 15:54:26 +0100 | [diff] [blame] | 243 | spin_lock_irq(sch->lock); |
Cornelia Huck | c820de3 | 2008-07-14 09:58:45 +0200 | [diff] [blame] | 244 | if (sch->driver && sch->driver->chp_event) |
| 245 | sch->driver->chp_event(sch, data, CHP_ONLINE); |
Cornelia Huck | 2ec2298 | 2006-12-08 15:54:26 +0100 | [diff] [blame] | 246 | spin_unlock_irq(sch->lock); |
Peter Oberparleiter | e82a156 | 2008-01-26 14:10:48 +0100 | [diff] [blame] | 247 | |
Peter Oberparleiter | dd9963f | 2006-09-20 15:59:54 +0200 | [diff] [blame] | 248 | return 0; |
Cornelia Huck | f97a56f | 2006-01-06 00:19:22 -0800 | [diff] [blame] | 249 | } |
| 250 | |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 251 | static void s390_process_res_acc(struct chp_link *link) |
Cornelia Huck | f97a56f | 2006-01-06 00:19:22 -0800 | [diff] [blame] | 252 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | char dbf_txt[15]; |
| 254 | |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 255 | sprintf(dbf_txt, "accpr%x.%02x", link->chpid.cssid, |
| 256 | link->chpid.id); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | CIO_TRACE_EVENT( 2, dbf_txt); |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 258 | if (link->fla != 0) { |
| 259 | sprintf(dbf_txt, "fla%x", link->fla); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | CIO_TRACE_EVENT( 2, dbf_txt); |
| 261 | } |
Cornelia Huck | 22806dc | 2008-04-17 07:45:59 +0200 | [diff] [blame] | 262 | /* Wait until previous actions have settled. */ |
| 263 | css_wait_for_slow_path(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | /* |
| 265 | * I/O resources may have become accessible. |
| 266 | * Scan through all subchannels that may be concerned and |
| 267 | * do a validation on those. |
| 268 | * The more information we have (info), the less scanning |
| 269 | * will we have to do. |
| 270 | */ |
Peter Oberparleiter | 449666d | 2013-11-26 14:55:56 +0100 | [diff] [blame] | 271 | for_each_subchannel_staged(__s390_process_res_acc, NULL, link); |
| 272 | css_schedule_reprobe(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 273 | } |
| 274 | |
| 275 | static int |
| 276 | __get_chpid_from_lir(void *data) |
| 277 | { |
| 278 | struct lir { |
| 279 | u8 iq; |
| 280 | u8 ic; |
| 281 | u16 sci; |
| 282 | /* incident-node descriptor */ |
| 283 | u32 indesc[28]; |
| 284 | /* attached-node descriptor */ |
| 285 | u32 andesc[28]; |
| 286 | /* incident-specific information */ |
| 287 | u32 isinfo[28]; |
Peter Oberparleiter | 0f008aa | 2007-02-05 21:17:40 +0100 | [diff] [blame] | 288 | } __attribute__ ((packed)) *lir; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 289 | |
Cornelia Huck | 12975ae | 2006-10-11 15:31:47 +0200 | [diff] [blame] | 290 | lir = data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | if (!(lir->iq&0x80)) |
| 292 | /* NULL link incident record */ |
| 293 | return -EINVAL; |
| 294 | if (!(lir->indesc[0]&0xc0000000)) |
| 295 | /* node descriptor not valid */ |
| 296 | return -EINVAL; |
| 297 | if (!(lir->indesc[0]&0x10000000)) |
| 298 | /* don't handle device-type nodes - FIXME */ |
| 299 | return -EINVAL; |
| 300 | /* Byte 3 contains the chpid. Could also be CTCA, but we don't care */ |
| 301 | |
| 302 | return (u16) (lir->indesc[0]&0x000000ff); |
| 303 | } |
| 304 | |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 305 | struct chsc_sei_nt0_area { |
| 306 | u8 flags; |
| 307 | u8 vf; /* validity flags */ |
| 308 | u8 rs; /* reporting source */ |
| 309 | u8 cc; /* content code */ |
| 310 | u16 fla; /* full link address */ |
| 311 | u16 rsid; /* reporting source id */ |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 312 | u32 reserved1; |
| 313 | u32 reserved2; |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 314 | /* ccdf has to be big enough for a link-incident record */ |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 315 | u8 ccdf[PAGE_SIZE - 24 - 16]; /* content-code dependent field */ |
| 316 | } __packed; |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 317 | |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 318 | struct chsc_sei_nt2_area { |
| 319 | u8 flags; /* p and v bit */ |
| 320 | u8 reserved1; |
| 321 | u8 reserved2; |
| 322 | u8 cc; /* content code */ |
| 323 | u32 reserved3[13]; |
| 324 | u8 ccdf[PAGE_SIZE - 24 - 56]; /* content-code dependent field */ |
| 325 | } __packed; |
| 326 | |
Sebastian Ott | 509d97b | 2013-01-15 19:02:01 +0100 | [diff] [blame] | 327 | #define CHSC_SEI_NT0 (1ULL << 63) |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 328 | #define CHSC_SEI_NT2 (1ULL << 61) |
| 329 | |
| 330 | struct chsc_sei { |
| 331 | struct chsc_header request; |
| 332 | u32 reserved1; |
| 333 | u64 ntsm; /* notification type mask */ |
| 334 | struct chsc_header response; |
Sebastian Ott | 509d97b | 2013-01-15 19:02:01 +0100 | [diff] [blame] | 335 | u32 :24; |
| 336 | u8 nt; |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 337 | union { |
| 338 | struct chsc_sei_nt0_area nt0_area; |
| 339 | struct chsc_sei_nt2_area nt2_area; |
| 340 | u8 nt_area[PAGE_SIZE - 24]; |
| 341 | } u; |
| 342 | } __packed; |
| 343 | |
| 344 | static void chsc_process_sei_link_incident(struct chsc_sei_nt0_area *sei_area) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 345 | { |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 346 | struct chp_id chpid; |
| 347 | int id; |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 348 | |
| 349 | CIO_CRW_EVENT(4, "chsc: link incident (rs=%02x, rs_id=%04x)\n", |
| 350 | sei_area->rs, sei_area->rsid); |
| 351 | if (sei_area->rs != 4) |
Peter Oberparleiter | 83b3370 | 2007-04-27 16:01:34 +0200 | [diff] [blame] | 352 | return; |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 353 | id = __get_chpid_from_lir(sei_area->ccdf); |
| 354 | if (id < 0) |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 355 | CIO_CRW_EVENT(4, "chsc: link incident - invalid LIR\n"); |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 356 | else { |
| 357 | chp_id_init(&chpid); |
| 358 | chpid.id = id; |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 359 | chsc_chp_offline(chpid); |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 360 | } |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 361 | } |
| 362 | |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 363 | static void chsc_process_sei_res_acc(struct chsc_sei_nt0_area *sei_area) |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 364 | { |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 365 | struct chp_link link; |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 366 | struct chp_id chpid; |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 367 | int status; |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 368 | |
| 369 | CIO_CRW_EVENT(4, "chsc: resource accessibility event (rs=%02x, " |
| 370 | "rs_id=%04x)\n", sei_area->rs, sei_area->rsid); |
| 371 | if (sei_area->rs != 4) |
Peter Oberparleiter | 83b3370 | 2007-04-27 16:01:34 +0200 | [diff] [blame] | 372 | return; |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 373 | chp_id_init(&chpid); |
| 374 | chpid.id = sei_area->rsid; |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 375 | /* allocate a new channel path structure, if needed */ |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 376 | status = chp_get_status(chpid); |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 377 | if (status < 0) |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 378 | chp_new(chpid); |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 379 | else if (!status) |
Peter Oberparleiter | 83b3370 | 2007-04-27 16:01:34 +0200 | [diff] [blame] | 380 | return; |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 381 | memset(&link, 0, sizeof(struct chp_link)); |
| 382 | link.chpid = chpid; |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 383 | if ((sei_area->vf & 0xc0) != 0) { |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 384 | link.fla = sei_area->fla; |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 385 | if ((sei_area->vf & 0xc0) == 0xc0) |
| 386 | /* full link address */ |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 387 | link.fla_mask = 0xffff; |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 388 | else |
| 389 | /* link address */ |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 390 | link.fla_mask = 0xff00; |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 391 | } |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 392 | s390_process_res_acc(&link); |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 393 | } |
| 394 | |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 395 | static void chsc_process_sei_chp_avail(struct chsc_sei_nt0_area *sei_area) |
Sebastian Ott | fca894ed | 2011-05-23 10:24:41 +0200 | [diff] [blame] | 396 | { |
| 397 | struct channel_path *chp; |
| 398 | struct chp_id chpid; |
| 399 | u8 *data; |
| 400 | int num; |
| 401 | |
| 402 | CIO_CRW_EVENT(4, "chsc: channel path availability information\n"); |
| 403 | if (sei_area->rs != 0) |
| 404 | return; |
| 405 | data = sei_area->ccdf; |
| 406 | chp_id_init(&chpid); |
| 407 | for (num = 0; num <= __MAX_CHPID; num++) { |
| 408 | if (!chp_test_bit(data, num)) |
| 409 | continue; |
| 410 | chpid.id = num; |
| 411 | |
| 412 | CIO_CRW_EVENT(4, "Update information for channel path " |
| 413 | "%x.%02x\n", chpid.cssid, chpid.id); |
| 414 | chp = chpid_to_chp(chpid); |
| 415 | if (!chp) { |
| 416 | chp_new(chpid); |
| 417 | continue; |
| 418 | } |
| 419 | mutex_lock(&chp->lock); |
Peter Oberparleiter | cce0eac | 2013-03-11 12:58:18 +0100 | [diff] [blame] | 420 | chp_update_desc(chp); |
Sebastian Ott | fca894ed | 2011-05-23 10:24:41 +0200 | [diff] [blame] | 421 | mutex_unlock(&chp->lock); |
| 422 | } |
| 423 | } |
| 424 | |
Peter Oberparleiter | e5854a5 | 2007-04-27 16:01:31 +0200 | [diff] [blame] | 425 | struct chp_config_data { |
| 426 | u8 map[32]; |
| 427 | u8 op; |
| 428 | u8 pc; |
| 429 | }; |
| 430 | |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 431 | static void chsc_process_sei_chp_config(struct chsc_sei_nt0_area *sei_area) |
Peter Oberparleiter | e5854a5 | 2007-04-27 16:01:31 +0200 | [diff] [blame] | 432 | { |
| 433 | struct chp_config_data *data; |
| 434 | struct chp_id chpid; |
| 435 | int num; |
Michael Ernst | e6d5a42 | 2008-12-25 13:39:36 +0100 | [diff] [blame] | 436 | char *events[3] = {"configure", "deconfigure", "cancel deconfigure"}; |
Peter Oberparleiter | e5854a5 | 2007-04-27 16:01:31 +0200 | [diff] [blame] | 437 | |
| 438 | CIO_CRW_EVENT(4, "chsc: channel-path-configuration notification\n"); |
| 439 | if (sei_area->rs != 0) |
Peter Oberparleiter | 83b3370 | 2007-04-27 16:01:34 +0200 | [diff] [blame] | 440 | return; |
Peter Oberparleiter | e5854a5 | 2007-04-27 16:01:31 +0200 | [diff] [blame] | 441 | data = (struct chp_config_data *) &(sei_area->ccdf); |
| 442 | chp_id_init(&chpid); |
| 443 | for (num = 0; num <= __MAX_CHPID; num++) { |
| 444 | if (!chp_test_bit(data->map, num)) |
| 445 | continue; |
| 446 | chpid.id = num; |
Michael Ernst | e6d5a42 | 2008-12-25 13:39:36 +0100 | [diff] [blame] | 447 | pr_notice("Processing %s for channel path %x.%02x\n", |
| 448 | events[data->op], chpid.cssid, chpid.id); |
Peter Oberparleiter | e5854a5 | 2007-04-27 16:01:31 +0200 | [diff] [blame] | 449 | switch (data->op) { |
| 450 | case 0: |
| 451 | chp_cfg_schedule(chpid, 1); |
| 452 | break; |
| 453 | case 1: |
| 454 | chp_cfg_schedule(chpid, 0); |
| 455 | break; |
| 456 | case 2: |
| 457 | chp_cfg_cancel_deconfigure(chpid); |
| 458 | break; |
| 459 | } |
| 460 | } |
Peter Oberparleiter | e5854a5 | 2007-04-27 16:01:31 +0200 | [diff] [blame] | 461 | } |
| 462 | |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 463 | static void chsc_process_sei_scm_change(struct chsc_sei_nt0_area *sei_area) |
Sebastian Ott | 40ff4cc | 2012-08-28 16:47:02 +0200 | [diff] [blame] | 464 | { |
| 465 | int ret; |
| 466 | |
| 467 | CIO_CRW_EVENT(4, "chsc: scm change notification\n"); |
| 468 | if (sei_area->rs != 7) |
| 469 | return; |
| 470 | |
| 471 | ret = scm_update_information(); |
| 472 | if (ret) |
| 473 | CIO_CRW_EVENT(0, "chsc: updating change notification" |
| 474 | " failed (rc=%d).\n", ret); |
| 475 | } |
| 476 | |
Sebastian Ott | aebfa66 | 2013-02-28 12:07:55 +0100 | [diff] [blame] | 477 | static void chsc_process_sei_scm_avail(struct chsc_sei_nt0_area *sei_area) |
| 478 | { |
| 479 | int ret; |
| 480 | |
| 481 | CIO_CRW_EVENT(4, "chsc: scm available information\n"); |
| 482 | if (sei_area->rs != 7) |
| 483 | return; |
| 484 | |
| 485 | ret = scm_process_availability_information(); |
| 486 | if (ret) |
| 487 | CIO_CRW_EVENT(0, "chsc: process availability information" |
| 488 | " failed (rc=%d).\n", ret); |
| 489 | } |
| 490 | |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 491 | static void chsc_process_sei_nt2(struct chsc_sei_nt2_area *sei_area) |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 492 | { |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 493 | switch (sei_area->cc) { |
| 494 | case 1: |
| 495 | zpci_event_error(sei_area->ccdf); |
| 496 | break; |
| 497 | case 2: |
| 498 | zpci_event_availability(sei_area->ccdf); |
| 499 | break; |
| 500 | default: |
Sebastian Ott | 9a17e97 | 2013-01-15 19:04:39 +0100 | [diff] [blame] | 501 | CIO_CRW_EVENT(2, "chsc: sei nt2 unhandled cc=%d\n", |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 502 | sei_area->cc); |
| 503 | break; |
Peter Oberparleiter | 83b3370 | 2007-04-27 16:01:34 +0200 | [diff] [blame] | 504 | } |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 505 | } |
| 506 | |
| 507 | static void chsc_process_sei_nt0(struct chsc_sei_nt0_area *sei_area) |
| 508 | { |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 509 | /* which kind of information was stored? */ |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 510 | switch (sei_area->cc) { |
| 511 | case 1: /* link incident*/ |
Peter Oberparleiter | 83b3370 | 2007-04-27 16:01:34 +0200 | [diff] [blame] | 512 | chsc_process_sei_link_incident(sei_area); |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 513 | break; |
Sebastian Ott | fca894ed | 2011-05-23 10:24:41 +0200 | [diff] [blame] | 514 | case 2: /* i/o resource accessibility */ |
Peter Oberparleiter | 83b3370 | 2007-04-27 16:01:34 +0200 | [diff] [blame] | 515 | chsc_process_sei_res_acc(sei_area); |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 516 | break; |
Sebastian Ott | fca894ed | 2011-05-23 10:24:41 +0200 | [diff] [blame] | 517 | case 7: /* channel-path-availability information */ |
| 518 | chsc_process_sei_chp_avail(sei_area); |
| 519 | break; |
Peter Oberparleiter | e5854a5 | 2007-04-27 16:01:31 +0200 | [diff] [blame] | 520 | case 8: /* channel-path-configuration notification */ |
Peter Oberparleiter | 83b3370 | 2007-04-27 16:01:34 +0200 | [diff] [blame] | 521 | chsc_process_sei_chp_config(sei_area); |
Peter Oberparleiter | e5854a5 | 2007-04-27 16:01:31 +0200 | [diff] [blame] | 522 | break; |
Sebastian Ott | 40ff4cc | 2012-08-28 16:47:02 +0200 | [diff] [blame] | 523 | case 12: /* scm change notification */ |
| 524 | chsc_process_sei_scm_change(sei_area); |
| 525 | break; |
Sebastian Ott | aebfa66 | 2013-02-28 12:07:55 +0100 | [diff] [blame] | 526 | case 14: /* scm available notification */ |
| 527 | chsc_process_sei_scm_avail(sei_area); |
| 528 | break; |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 529 | default: /* other stuff */ |
Sebastian Ott | 9a17e97 | 2013-01-15 19:04:39 +0100 | [diff] [blame] | 530 | CIO_CRW_EVENT(2, "chsc: sei nt0 unhandled cc=%d\n", |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 531 | sei_area->cc); |
| 532 | break; |
| 533 | } |
Sebastian Ott | 9a17e97 | 2013-01-15 19:04:39 +0100 | [diff] [blame] | 534 | |
| 535 | /* Check if we might have lost some information. */ |
| 536 | if (sei_area->flags & 0x40) { |
| 537 | CIO_CRW_EVENT(2, "chsc: event overflow\n"); |
| 538 | css_schedule_eval_all(); |
| 539 | } |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 540 | } |
| 541 | |
Sebastian Ott | 9a17e97 | 2013-01-15 19:04:39 +0100 | [diff] [blame] | 542 | static void chsc_process_event_information(struct chsc_sei *sei, u64 ntsm) |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 543 | { |
| 544 | do { |
| 545 | memset(sei, 0, sizeof(*sei)); |
| 546 | sei->request.length = 0x0010; |
| 547 | sei->request.code = 0x000e; |
| 548 | sei->ntsm = ntsm; |
| 549 | |
| 550 | if (chsc(sei)) |
| 551 | break; |
| 552 | |
Sebastian Ott | 9a17e97 | 2013-01-15 19:04:39 +0100 | [diff] [blame] | 553 | if (sei->response.code != 0x0001) { |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 554 | CIO_CRW_EVENT(2, "chsc: sei failed (rc=%04x)\n", |
| 555 | sei->response.code); |
| 556 | break; |
| 557 | } |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 558 | |
Sebastian Ott | 9a17e97 | 2013-01-15 19:04:39 +0100 | [diff] [blame] | 559 | CIO_CRW_EVENT(2, "chsc: sei successful (nt=%d)\n", sei->nt); |
| 560 | switch (sei->nt) { |
| 561 | case 0: |
| 562 | chsc_process_sei_nt0(&sei->u.nt0_area); |
| 563 | break; |
| 564 | case 2: |
| 565 | chsc_process_sei_nt2(&sei->u.nt2_area); |
| 566 | break; |
| 567 | default: |
| 568 | CIO_CRW_EVENT(2, "chsc: unhandled nt: %d\n", sei->nt); |
| 569 | break; |
| 570 | } |
| 571 | } while (sei->u.nt0_area.flags & 0x80); |
Jan Glauber | cbc0dd1 | 2012-11-29 14:34:48 +0100 | [diff] [blame] | 572 | } |
| 573 | |
Sebastian Ott | 9a17e97 | 2013-01-15 19:04:39 +0100 | [diff] [blame] | 574 | /* |
| 575 | * Handle channel subsystem related CRWs. |
| 576 | * Use store event information to find out what's going on. |
| 577 | * |
| 578 | * Note: Access to sei_page is serialized through machine check handler |
| 579 | * thread, so no need for locking. |
| 580 | */ |
Cornelia Huck | c115618 | 2008-07-14 09:58:46 +0200 | [diff] [blame] | 581 | static void chsc_process_crw(struct crw *crw0, struct crw *crw1, int overflow) |
Peter Oberparleiter | 184357a | 2007-02-05 21:17:42 +0100 | [diff] [blame] | 582 | { |
Sebastian Ott | 9a17e97 | 2013-01-15 19:04:39 +0100 | [diff] [blame] | 583 | struct chsc_sei *sei = sei_page; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 584 | |
Cornelia Huck | c115618 | 2008-07-14 09:58:46 +0200 | [diff] [blame] | 585 | if (overflow) { |
| 586 | css_schedule_eval_all(); |
| 587 | return; |
| 588 | } |
| 589 | CIO_CRW_EVENT(2, "CRW reports slct=%d, oflw=%d, " |
| 590 | "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n", |
| 591 | crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc, |
| 592 | crw0->erc, crw0->rsid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 593 | |
Cornelia Huck | c115618 | 2008-07-14 09:58:46 +0200 | [diff] [blame] | 594 | CIO_TRACE_EVENT(2, "prcss"); |
Sebastian Ott | 9a17e97 | 2013-01-15 19:04:39 +0100 | [diff] [blame] | 595 | chsc_process_event_information(sei, CHSC_SEI_NT0 | CHSC_SEI_NT2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 596 | } |
| 597 | |
Peter Oberparleiter | 83b3370 | 2007-04-27 16:01:34 +0200 | [diff] [blame] | 598 | void chsc_chp_online(struct chp_id chpid) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 599 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 600 | char dbf_txt[15]; |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 601 | struct chp_link link; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 602 | |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 603 | sprintf(dbf_txt, "cadd%x.%02x", chpid.cssid, chpid.id); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 604 | CIO_TRACE_EVENT(2, dbf_txt); |
| 605 | |
Cornelia Huck | 22806dc | 2008-04-17 07:45:59 +0200 | [diff] [blame] | 606 | if (chp_get_status(chpid) != 0) { |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 607 | memset(&link, 0, sizeof(struct chp_link)); |
| 608 | link.chpid = chpid; |
Cornelia Huck | 22806dc | 2008-04-17 07:45:59 +0200 | [diff] [blame] | 609 | /* Wait until previous actions have settled. */ |
| 610 | css_wait_for_slow_path(); |
Cornelia Huck | c820de3 | 2008-07-14 09:58:45 +0200 | [diff] [blame] | 611 | for_each_subchannel_staged(__s390_process_res_acc, NULL, |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 612 | &link); |
Peter Oberparleiter | 9955e8d1 | 2014-02-19 17:43:04 +0100 | [diff] [blame^] | 613 | css_schedule_reprobe(); |
Cornelia Huck | 22806dc | 2008-04-17 07:45:59 +0200 | [diff] [blame] | 614 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 615 | } |
| 616 | |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 617 | static void __s390_subchannel_vary_chpid(struct subchannel *sch, |
| 618 | struct chp_id chpid, int on) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 619 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 620 | unsigned long flags; |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 621 | struct chp_link link; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 622 | |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 623 | memset(&link, 0, sizeof(struct chp_link)); |
| 624 | link.chpid = chpid; |
Cornelia Huck | 2ec2298 | 2006-12-08 15:54:26 +0100 | [diff] [blame] | 625 | spin_lock_irqsave(sch->lock, flags); |
Cornelia Huck | c820de3 | 2008-07-14 09:58:45 +0200 | [diff] [blame] | 626 | if (sch->driver && sch->driver->chp_event) |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 627 | sch->driver->chp_event(sch, &link, |
Cornelia Huck | c820de3 | 2008-07-14 09:58:45 +0200 | [diff] [blame] | 628 | on ? CHP_VARY_ON : CHP_VARY_OFF); |
Cornelia Huck | 2ec2298 | 2006-12-08 15:54:26 +0100 | [diff] [blame] | 629 | spin_unlock_irqrestore(sch->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 630 | } |
| 631 | |
Peter Oberparleiter | e82a156 | 2008-01-26 14:10:48 +0100 | [diff] [blame] | 632 | static int s390_subchannel_vary_chpid_off(struct subchannel *sch, void *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 633 | { |
Peter Oberparleiter | e82a156 | 2008-01-26 14:10:48 +0100 | [diff] [blame] | 634 | struct chp_id *chpid = data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 635 | |
| 636 | __s390_subchannel_vary_chpid(sch, *chpid, 0); |
| 637 | return 0; |
| 638 | } |
| 639 | |
Peter Oberparleiter | e82a156 | 2008-01-26 14:10:48 +0100 | [diff] [blame] | 640 | static int s390_subchannel_vary_chpid_on(struct subchannel *sch, void *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 641 | { |
Peter Oberparleiter | e82a156 | 2008-01-26 14:10:48 +0100 | [diff] [blame] | 642 | struct chp_id *chpid = data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 643 | |
| 644 | __s390_subchannel_vary_chpid(sch, *chpid, 1); |
| 645 | return 0; |
| 646 | } |
| 647 | |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 648 | /** |
| 649 | * chsc_chp_vary - propagate channel-path vary operation to subchannels |
| 650 | * @chpid: channl-path ID |
| 651 | * @on: non-zero for vary online, zero for vary offline |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 652 | */ |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 653 | int chsc_chp_vary(struct chp_id chpid, int on) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 654 | { |
Sebastian Ott | c38a90a | 2010-10-25 16:10:31 +0200 | [diff] [blame] | 655 | struct channel_path *chp = chpid_to_chp(chpid); |
Cornelia Huck | 99611f8 | 2008-07-14 09:59:02 +0200 | [diff] [blame] | 656 | |
Cornelia Huck | 22806dc | 2008-04-17 07:45:59 +0200 | [diff] [blame] | 657 | /* Wait until previous actions have settled. */ |
| 658 | css_wait_for_slow_path(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 659 | /* |
| 660 | * Redo PathVerification on the devices the chpid connects to |
| 661 | */ |
Sebastian Ott | c38a90a | 2010-10-25 16:10:31 +0200 | [diff] [blame] | 662 | if (on) { |
Peter Oberparleiter | cce0eac | 2013-03-11 12:58:18 +0100 | [diff] [blame] | 663 | /* Try to update the channel path description. */ |
| 664 | chp_update_desc(chp); |
Peter Oberparleiter | e82a156 | 2008-01-26 14:10:48 +0100 | [diff] [blame] | 665 | for_each_subchannel_staged(s390_subchannel_vary_chpid_on, |
Peter Oberparleiter | 449666d | 2013-11-26 14:55:56 +0100 | [diff] [blame] | 666 | NULL, &chpid); |
| 667 | css_schedule_reprobe(); |
Sebastian Ott | c38a90a | 2010-10-25 16:10:31 +0200 | [diff] [blame] | 668 | } else |
Peter Oberparleiter | e82a156 | 2008-01-26 14:10:48 +0100 | [diff] [blame] | 669 | for_each_subchannel_staged(s390_subchannel_vary_chpid_off, |
Sebastian Ott | 3b484ec | 2011-12-01 13:32:22 +0100 | [diff] [blame] | 670 | NULL, &chpid); |
Peter Oberparleiter | e82a156 | 2008-01-26 14:10:48 +0100 | [diff] [blame] | 671 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 672 | return 0; |
| 673 | } |
| 674 | |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 675 | static void |
| 676 | chsc_remove_cmg_attr(struct channel_subsystem *css) |
| 677 | { |
| 678 | int i; |
| 679 | |
| 680 | for (i = 0; i <= __MAX_CHPID; i++) { |
| 681 | if (!css->chps[i]) |
| 682 | continue; |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 683 | chp_remove_cmg_attr(css->chps[i]); |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 684 | } |
| 685 | } |
| 686 | |
| 687 | static int |
| 688 | chsc_add_cmg_attr(struct channel_subsystem *css) |
| 689 | { |
| 690 | int i, ret; |
| 691 | |
| 692 | ret = 0; |
| 693 | for (i = 0; i <= __MAX_CHPID; i++) { |
| 694 | if (!css->chps[i]) |
| 695 | continue; |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 696 | ret = chp_add_cmg_attr(css->chps[i]); |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 697 | if (ret) |
| 698 | goto cleanup; |
| 699 | } |
| 700 | return ret; |
| 701 | cleanup: |
| 702 | for (--i; i >= 0; i--) { |
| 703 | if (!css->chps[i]) |
| 704 | continue; |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 705 | chp_remove_cmg_attr(css->chps[i]); |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 706 | } |
| 707 | return ret; |
| 708 | } |
| 709 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 710 | int __chsc_do_secm(struct channel_subsystem *css, int enable) |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 711 | { |
| 712 | struct { |
| 713 | struct chsc_header request; |
| 714 | u32 operation_code : 2; |
| 715 | u32 : 30; |
| 716 | u32 key : 4; |
| 717 | u32 : 28; |
| 718 | u32 zeroes1; |
| 719 | u32 cub_addr1; |
| 720 | u32 zeroes2; |
| 721 | u32 cub_addr2; |
| 722 | u32 reserved[13]; |
| 723 | struct chsc_header response; |
| 724 | u32 status : 8; |
| 725 | u32 : 4; |
| 726 | u32 fmt : 4; |
| 727 | u32 : 16; |
Peter Oberparleiter | 0f008aa | 2007-02-05 21:17:40 +0100 | [diff] [blame] | 728 | } __attribute__ ((packed)) *secm_area; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 729 | int ret, ccode; |
| 730 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 731 | spin_lock_irq(&chsc_page_lock); |
| 732 | memset(chsc_page, 0, PAGE_SIZE); |
| 733 | secm_area = chsc_page; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 734 | secm_area->request.length = 0x0050; |
| 735 | secm_area->request.code = 0x0016; |
| 736 | |
Heiko Carstens | d1bf859 | 2010-02-26 22:37:30 +0100 | [diff] [blame] | 737 | secm_area->key = PAGE_DEFAULT_KEY >> 4; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 738 | secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1; |
| 739 | secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2; |
| 740 | |
| 741 | secm_area->operation_code = enable ? 0 : 1; |
| 742 | |
| 743 | ccode = chsc(secm_area); |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 744 | if (ccode > 0) { |
| 745 | ret = (ccode == 3) ? -ENODEV : -EBUSY; |
| 746 | goto out; |
| 747 | } |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 748 | |
| 749 | switch (secm_area->response.code) { |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 750 | case 0x0102: |
| 751 | case 0x0103: |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 752 | ret = -EINVAL; |
Sebastian Ott | 17e7d87 | 2009-03-26 15:24:17 +0100 | [diff] [blame] | 753 | break; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 754 | default: |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 755 | ret = chsc_error_from_response(secm_area->response.code); |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 756 | } |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 757 | if (ret != 0) |
| 758 | CIO_CRW_EVENT(2, "chsc: secm failed (rc=%04x)\n", |
| 759 | secm_area->response.code); |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 760 | out: |
| 761 | spin_unlock_irq(&chsc_page_lock); |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 762 | return ret; |
| 763 | } |
| 764 | |
| 765 | int |
| 766 | chsc_secm(struct channel_subsystem *css, int enable) |
| 767 | { |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 768 | int ret; |
| 769 | |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 770 | if (enable && !css->cm_enabled) { |
| 771 | css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); |
| 772 | css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); |
| 773 | if (!css->cub_addr1 || !css->cub_addr2) { |
| 774 | free_page((unsigned long)css->cub_addr1); |
| 775 | free_page((unsigned long)css->cub_addr2); |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 776 | return -ENOMEM; |
| 777 | } |
| 778 | } |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 779 | ret = __chsc_do_secm(css, enable); |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 780 | if (!ret) { |
| 781 | css->cm_enabled = enable; |
| 782 | if (css->cm_enabled) { |
| 783 | ret = chsc_add_cmg_attr(css); |
| 784 | if (ret) { |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 785 | __chsc_do_secm(css, 0); |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 786 | css->cm_enabled = 0; |
| 787 | } |
| 788 | } else |
| 789 | chsc_remove_cmg_attr(css); |
| 790 | } |
Cornelia Huck | 8c4941c | 2007-04-27 16:01:38 +0200 | [diff] [blame] | 791 | if (!css->cm_enabled) { |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 792 | free_page((unsigned long)css->cub_addr1); |
| 793 | free_page((unsigned long)css->cub_addr2); |
| 794 | } |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 795 | return ret; |
| 796 | } |
| 797 | |
Cornelia Huck | 9d92a7e | 2008-07-14 09:59:05 +0200 | [diff] [blame] | 798 | int chsc_determine_channel_path_desc(struct chp_id chpid, int fmt, int rfmt, |
Sebastian Ott | 906c976 | 2010-10-25 16:10:30 +0200 | [diff] [blame] | 799 | int c, int m, void *page) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 800 | { |
Sebastian Ott | 906c976 | 2010-10-25 16:10:30 +0200 | [diff] [blame] | 801 | struct chsc_scpd *scpd_area; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 802 | int ccode, ret; |
| 803 | |
Cornelia Huck | 9d92a7e | 2008-07-14 09:59:05 +0200 | [diff] [blame] | 804 | if ((rfmt == 1) && !css_general_characteristics.fcs) |
| 805 | return -EINVAL; |
| 806 | if ((rfmt == 2) && !css_general_characteristics.cib) |
| 807 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 808 | |
Sebastian Ott | 906c976 | 2010-10-25 16:10:30 +0200 | [diff] [blame] | 809 | memset(page, 0, PAGE_SIZE); |
| 810 | scpd_area = page; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 811 | scpd_area->request.length = 0x0010; |
| 812 | scpd_area->request.code = 0x0002; |
Cornelia Huck | 9d92a7e | 2008-07-14 09:59:05 +0200 | [diff] [blame] | 813 | scpd_area->cssid = chpid.cssid; |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 814 | scpd_area->first_chpid = chpid.id; |
| 815 | scpd_area->last_chpid = chpid.id; |
Cornelia Huck | 9d92a7e | 2008-07-14 09:59:05 +0200 | [diff] [blame] | 816 | scpd_area->m = m; |
| 817 | scpd_area->c = c; |
| 818 | scpd_area->fmt = fmt; |
| 819 | scpd_area->rfmt = rfmt; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 820 | |
| 821 | ccode = chsc(scpd_area); |
Sebastian Ott | 906c976 | 2010-10-25 16:10:30 +0200 | [diff] [blame] | 822 | if (ccode > 0) |
| 823 | return (ccode == 3) ? -ENODEV : -EBUSY; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 824 | |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 825 | ret = chsc_error_from_response(scpd_area->response.code); |
Sebastian Ott | 906c976 | 2010-10-25 16:10:30 +0200 | [diff] [blame] | 826 | if (ret) |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 827 | CIO_CRW_EVENT(2, "chsc: scpd failed (rc=%04x)\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 828 | scpd_area->response.code); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 829 | return ret; |
| 830 | } |
Cornelia Huck | 9d92a7e | 2008-07-14 09:59:05 +0200 | [diff] [blame] | 831 | EXPORT_SYMBOL_GPL(chsc_determine_channel_path_desc); |
| 832 | |
| 833 | int chsc_determine_base_channel_path_desc(struct chp_id chpid, |
| 834 | struct channel_path_desc *desc) |
| 835 | { |
| 836 | struct chsc_response_struct *chsc_resp; |
Sebastian Ott | 906c976 | 2010-10-25 16:10:30 +0200 | [diff] [blame] | 837 | struct chsc_scpd *scpd_area; |
Sebastian Ott | 62da177 | 2010-10-25 16:10:32 +0200 | [diff] [blame] | 838 | unsigned long flags; |
Cornelia Huck | 9d92a7e | 2008-07-14 09:59:05 +0200 | [diff] [blame] | 839 | int ret; |
| 840 | |
Sebastian Ott | 62da177 | 2010-10-25 16:10:32 +0200 | [diff] [blame] | 841 | spin_lock_irqsave(&chsc_page_lock, flags); |
Sebastian Ott | 906c976 | 2010-10-25 16:10:30 +0200 | [diff] [blame] | 842 | scpd_area = chsc_page; |
| 843 | ret = chsc_determine_channel_path_desc(chpid, 0, 0, 0, 0, scpd_area); |
Cornelia Huck | 9d92a7e | 2008-07-14 09:59:05 +0200 | [diff] [blame] | 844 | if (ret) |
Sebastian Ott | 906c976 | 2010-10-25 16:10:30 +0200 | [diff] [blame] | 845 | goto out; |
| 846 | chsc_resp = (void *)&scpd_area->response; |
Sebastian Ott | 878c495 | 2010-07-19 09:22:37 +0200 | [diff] [blame] | 847 | memcpy(desc, &chsc_resp->data, sizeof(*desc)); |
Sebastian Ott | 906c976 | 2010-10-25 16:10:30 +0200 | [diff] [blame] | 848 | out: |
Sebastian Ott | 62da177 | 2010-10-25 16:10:32 +0200 | [diff] [blame] | 849 | spin_unlock_irqrestore(&chsc_page_lock, flags); |
Cornelia Huck | 9d92a7e | 2008-07-14 09:59:05 +0200 | [diff] [blame] | 850 | return ret; |
| 851 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 852 | |
Sebastian Ott | ce322cc | 2011-01-05 12:47:56 +0100 | [diff] [blame] | 853 | int chsc_determine_fmt1_channel_path_desc(struct chp_id chpid, |
| 854 | struct channel_path_desc_fmt1 *desc) |
| 855 | { |
| 856 | struct chsc_response_struct *chsc_resp; |
| 857 | struct chsc_scpd *scpd_area; |
Peter Oberparleiter | cce0eac | 2013-03-11 12:58:18 +0100 | [diff] [blame] | 858 | unsigned long flags; |
Sebastian Ott | ce322cc | 2011-01-05 12:47:56 +0100 | [diff] [blame] | 859 | int ret; |
| 860 | |
Peter Oberparleiter | cce0eac | 2013-03-11 12:58:18 +0100 | [diff] [blame] | 861 | spin_lock_irqsave(&chsc_page_lock, flags); |
Sebastian Ott | ce322cc | 2011-01-05 12:47:56 +0100 | [diff] [blame] | 862 | scpd_area = chsc_page; |
| 863 | ret = chsc_determine_channel_path_desc(chpid, 0, 0, 1, 0, scpd_area); |
| 864 | if (ret) |
| 865 | goto out; |
| 866 | chsc_resp = (void *)&scpd_area->response; |
| 867 | memcpy(desc, &chsc_resp->data, sizeof(*desc)); |
| 868 | out: |
Peter Oberparleiter | cce0eac | 2013-03-11 12:58:18 +0100 | [diff] [blame] | 869 | spin_unlock_irqrestore(&chsc_page_lock, flags); |
Sebastian Ott | ce322cc | 2011-01-05 12:47:56 +0100 | [diff] [blame] | 870 | return ret; |
| 871 | } |
| 872 | |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 873 | static void |
| 874 | chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv, |
| 875 | struct cmg_chars *chars) |
| 876 | { |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 877 | struct cmg_chars *cmg_chars; |
| 878 | int i, mask; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 879 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 880 | cmg_chars = chp->cmg_chars; |
| 881 | for (i = 0; i < NR_MEASUREMENT_CHARS; i++) { |
| 882 | mask = 0x80 >> (i + 3); |
| 883 | if (cmcv & mask) |
| 884 | cmg_chars->values[i] = chars->values[i]; |
| 885 | else |
| 886 | cmg_chars->values[i] = 0; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 887 | } |
| 888 | } |
| 889 | |
Peter Oberparleiter | e6b6e10 | 2007-04-27 16:01:28 +0200 | [diff] [blame] | 890 | int chsc_get_channel_measurement_chars(struct channel_path *chp) |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 891 | { |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 892 | struct cmg_chars *cmg_chars; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 893 | int ccode, ret; |
| 894 | |
| 895 | struct { |
| 896 | struct chsc_header request; |
| 897 | u32 : 24; |
| 898 | u32 first_chpid : 8; |
| 899 | u32 : 24; |
| 900 | u32 last_chpid : 8; |
| 901 | u32 zeroes1; |
| 902 | struct chsc_header response; |
| 903 | u32 zeroes2; |
| 904 | u32 not_valid : 1; |
| 905 | u32 shared : 1; |
| 906 | u32 : 22; |
| 907 | u32 chpid : 8; |
| 908 | u32 cmcv : 5; |
| 909 | u32 : 11; |
| 910 | u32 cmgq : 8; |
| 911 | u32 cmg : 8; |
| 912 | u32 zeroes3; |
| 913 | u32 data[NR_MEASUREMENT_CHARS]; |
Peter Oberparleiter | 0f008aa | 2007-02-05 21:17:40 +0100 | [diff] [blame] | 914 | } __attribute__ ((packed)) *scmc_area; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 915 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 916 | chp->cmg_chars = NULL; |
| 917 | cmg_chars = kmalloc(sizeof(*cmg_chars), GFP_KERNEL); |
| 918 | if (!cmg_chars) |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 919 | return -ENOMEM; |
| 920 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 921 | spin_lock_irq(&chsc_page_lock); |
| 922 | memset(chsc_page, 0, PAGE_SIZE); |
| 923 | scmc_area = chsc_page; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 924 | scmc_area->request.length = 0x0010; |
| 925 | scmc_area->request.code = 0x0022; |
Peter Oberparleiter | f86635f | 2007-04-27 16:01:26 +0200 | [diff] [blame] | 926 | scmc_area->first_chpid = chp->chpid.id; |
| 927 | scmc_area->last_chpid = chp->chpid.id; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 928 | |
| 929 | ccode = chsc(scmc_area); |
| 930 | if (ccode > 0) { |
| 931 | ret = (ccode == 3) ? -ENODEV : -EBUSY; |
| 932 | goto out; |
| 933 | } |
| 934 | |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 935 | ret = chsc_error_from_response(scmc_area->response.code); |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 936 | if (ret) { |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 937 | CIO_CRW_EVENT(2, "chsc: scmc failed (rc=%04x)\n", |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 938 | scmc_area->response.code); |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 939 | goto out; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 940 | } |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 941 | if (scmc_area->not_valid) { |
| 942 | chp->cmg = -1; |
| 943 | chp->shared = -1; |
| 944 | goto out; |
| 945 | } |
| 946 | chp->cmg = scmc_area->cmg; |
| 947 | chp->shared = scmc_area->shared; |
| 948 | if (chp->cmg != 2 && chp->cmg != 3) { |
| 949 | /* No cmg-dependent data. */ |
| 950 | goto out; |
| 951 | } |
| 952 | chp->cmg_chars = cmg_chars; |
| 953 | chsc_initialize_cmg_chars(chp, scmc_area->cmcv, |
| 954 | (struct cmg_chars *) &scmc_area->data); |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 955 | out: |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 956 | spin_unlock_irq(&chsc_page_lock); |
| 957 | if (!chp->cmg_chars) |
| 958 | kfree(cmg_chars); |
| 959 | |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 960 | return ret; |
| 961 | } |
| 962 | |
Sebastian Ott | 34aec07 | 2010-10-25 16:10:28 +0200 | [diff] [blame] | 963 | int __init chsc_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 964 | { |
Cornelia Huck | c115618 | 2008-07-14 09:58:46 +0200 | [diff] [blame] | 965 | int ret; |
| 966 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 967 | sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 968 | chsc_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); |
| 969 | if (!sei_page || !chsc_page) { |
| 970 | ret = -ENOMEM; |
| 971 | goto out_err; |
Cornelia Huck | c115618 | 2008-07-14 09:58:46 +0200 | [diff] [blame] | 972 | } |
Heiko Carstens | f5daba1 | 2009-03-26 15:24:01 +0100 | [diff] [blame] | 973 | ret = crw_register_handler(CRW_RSC_CSS, chsc_process_crw); |
Cornelia Huck | c115618 | 2008-07-14 09:58:46 +0200 | [diff] [blame] | 974 | if (ret) |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 975 | goto out_err; |
| 976 | return ret; |
| 977 | out_err: |
| 978 | free_page((unsigned long)chsc_page); |
| 979 | free_page((unsigned long)sei_page); |
Cornelia Huck | c115618 | 2008-07-14 09:58:46 +0200 | [diff] [blame] | 980 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 981 | } |
| 982 | |
Sebastian Ott | 34aec07 | 2010-10-25 16:10:28 +0200 | [diff] [blame] | 983 | void __init chsc_init_cleanup(void) |
Cornelia Huck | 4434a38 | 2007-07-27 12:29:21 +0200 | [diff] [blame] | 984 | { |
Heiko Carstens | f5daba1 | 2009-03-26 15:24:01 +0100 | [diff] [blame] | 985 | crw_unregister_handler(CRW_RSC_CSS); |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 986 | free_page((unsigned long)chsc_page); |
Sebastian Ott | 34aec07 | 2010-10-25 16:10:28 +0200 | [diff] [blame] | 987 | free_page((unsigned long)sei_page); |
Cornelia Huck | 4434a38 | 2007-07-27 12:29:21 +0200 | [diff] [blame] | 988 | } |
| 989 | |
Sebastian Ott | 818c272 | 2010-04-22 17:17:03 +0200 | [diff] [blame] | 990 | int chsc_enable_facility(int operation_code) |
Cornelia Huck | fb6958a | 2006-01-06 00:19:25 -0800 | [diff] [blame] | 991 | { |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 992 | unsigned long flags; |
Cornelia Huck | fb6958a | 2006-01-06 00:19:25 -0800 | [diff] [blame] | 993 | int ret; |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 994 | struct { |
Cornelia Huck | fb6958a | 2006-01-06 00:19:25 -0800 | [diff] [blame] | 995 | struct chsc_header request; |
| 996 | u8 reserved1:4; |
| 997 | u8 format:4; |
| 998 | u8 reserved2; |
| 999 | u16 operation_code; |
| 1000 | u32 reserved3; |
| 1001 | u32 reserved4; |
| 1002 | u32 operation_data_area[252]; |
| 1003 | struct chsc_header response; |
| 1004 | u32 reserved5:4; |
| 1005 | u32 format2:4; |
| 1006 | u32 reserved6:24; |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1007 | } __attribute__ ((packed)) *sda_area; |
Cornelia Huck | fb6958a | 2006-01-06 00:19:25 -0800 | [diff] [blame] | 1008 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1009 | spin_lock_irqsave(&chsc_page_lock, flags); |
| 1010 | memset(chsc_page, 0, PAGE_SIZE); |
| 1011 | sda_area = chsc_page; |
| 1012 | sda_area->request.length = 0x0400; |
| 1013 | sda_area->request.code = 0x0031; |
| 1014 | sda_area->operation_code = operation_code; |
Cornelia Huck | fb6958a | 2006-01-06 00:19:25 -0800 | [diff] [blame] | 1015 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1016 | ret = chsc(sda_area); |
Cornelia Huck | fb6958a | 2006-01-06 00:19:25 -0800 | [diff] [blame] | 1017 | if (ret > 0) { |
| 1018 | ret = (ret == 3) ? -ENODEV : -EBUSY; |
| 1019 | goto out; |
| 1020 | } |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 1021 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1022 | switch (sda_area->response.code) { |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 1023 | case 0x0101: |
Cornelia Huck | fb6958a | 2006-01-06 00:19:25 -0800 | [diff] [blame] | 1024 | ret = -EOPNOTSUPP; |
| 1025 | break; |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 1026 | default: |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1027 | ret = chsc_error_from_response(sda_area->response.code); |
Cornelia Huck | fb6958a | 2006-01-06 00:19:25 -0800 | [diff] [blame] | 1028 | } |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 1029 | if (ret != 0) |
| 1030 | CIO_CRW_EVENT(2, "chsc: sda (oc=%x) failed (rc=%04x)\n", |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1031 | operation_code, sda_area->response.code); |
| 1032 | out: |
| 1033 | spin_unlock_irqrestore(&chsc_page_lock, flags); |
Cornelia Huck | fb6958a | 2006-01-06 00:19:25 -0800 | [diff] [blame] | 1034 | return ret; |
| 1035 | } |
| 1036 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1037 | struct css_general_char css_general_characteristics; |
| 1038 | struct css_chsc_char css_chsc_characteristics; |
| 1039 | |
| 1040 | int __init |
| 1041 | chsc_determine_css_characteristics(void) |
| 1042 | { |
| 1043 | int result; |
| 1044 | struct { |
| 1045 | struct chsc_header request; |
| 1046 | u32 reserved1; |
| 1047 | u32 reserved2; |
| 1048 | u32 reserved3; |
| 1049 | struct chsc_header response; |
| 1050 | u32 reserved4; |
| 1051 | u32 general_char[510]; |
Sebastian Ott | 34aec07 | 2010-10-25 16:10:28 +0200 | [diff] [blame] | 1052 | u32 chsc_char[508]; |
Peter Oberparleiter | 0f008aa | 2007-02-05 21:17:40 +0100 | [diff] [blame] | 1053 | } __attribute__ ((packed)) *scsc_area; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1054 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1055 | spin_lock_irq(&chsc_page_lock); |
| 1056 | memset(chsc_page, 0, PAGE_SIZE); |
| 1057 | scsc_area = chsc_page; |
Cornelia Huck | 495a5b4 | 2006-03-24 03:15:14 -0800 | [diff] [blame] | 1058 | scsc_area->request.length = 0x0010; |
| 1059 | scsc_area->request.code = 0x0010; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1060 | |
| 1061 | result = chsc(scsc_area); |
| 1062 | if (result) { |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 1063 | result = (result == 3) ? -ENODEV : -EBUSY; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1064 | goto exit; |
| 1065 | } |
| 1066 | |
Cornelia Huck | b9c9a21 | 2008-02-05 16:50:34 +0100 | [diff] [blame] | 1067 | result = chsc_error_from_response(scsc_area->response.code); |
| 1068 | if (result == 0) { |
| 1069 | memcpy(&css_general_characteristics, scsc_area->general_char, |
| 1070 | sizeof(css_general_characteristics)); |
| 1071 | memcpy(&css_chsc_characteristics, scsc_area->chsc_char, |
| 1072 | sizeof(css_chsc_characteristics)); |
| 1073 | } else |
| 1074 | CIO_CRW_EVENT(2, "chsc: scsc failed (rc=%04x)\n", |
| 1075 | scsc_area->response.code); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1076 | exit: |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1077 | spin_unlock_irq(&chsc_page_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1078 | return result; |
| 1079 | } |
| 1080 | |
| 1081 | EXPORT_SYMBOL_GPL(css_general_characteristics); |
| 1082 | EXPORT_SYMBOL_GPL(css_chsc_characteristics); |
Martin Schwidefsky | d2fec59 | 2008-07-14 09:58:56 +0200 | [diff] [blame] | 1083 | |
| 1084 | int chsc_sstpc(void *page, unsigned int op, u16 ctrl) |
| 1085 | { |
| 1086 | struct { |
| 1087 | struct chsc_header request; |
| 1088 | unsigned int rsvd0; |
| 1089 | unsigned int op : 8; |
| 1090 | unsigned int rsvd1 : 8; |
| 1091 | unsigned int ctrl : 16; |
| 1092 | unsigned int rsvd2[5]; |
| 1093 | struct chsc_header response; |
| 1094 | unsigned int rsvd3[7]; |
| 1095 | } __attribute__ ((packed)) *rr; |
| 1096 | int rc; |
| 1097 | |
| 1098 | memset(page, 0, PAGE_SIZE); |
| 1099 | rr = page; |
| 1100 | rr->request.length = 0x0020; |
| 1101 | rr->request.code = 0x0033; |
| 1102 | rr->op = op; |
| 1103 | rr->ctrl = ctrl; |
| 1104 | rc = chsc(rr); |
| 1105 | if (rc) |
| 1106 | return -EIO; |
| 1107 | rc = (rr->response.code == 0x0001) ? 0 : -EIO; |
| 1108 | return rc; |
| 1109 | } |
| 1110 | |
| 1111 | int chsc_sstpi(void *page, void *result, size_t size) |
| 1112 | { |
| 1113 | struct { |
| 1114 | struct chsc_header request; |
| 1115 | unsigned int rsvd0[3]; |
| 1116 | struct chsc_header response; |
| 1117 | char data[size]; |
| 1118 | } __attribute__ ((packed)) *rr; |
| 1119 | int rc; |
| 1120 | |
| 1121 | memset(page, 0, PAGE_SIZE); |
| 1122 | rr = page; |
| 1123 | rr->request.length = 0x0010; |
| 1124 | rr->request.code = 0x0038; |
| 1125 | rc = chsc(rr); |
| 1126 | if (rc) |
| 1127 | return -EIO; |
| 1128 | memcpy(result, &rr->data, size); |
| 1129 | return (rr->response.code == 0x0001) ? 0 : -EIO; |
| 1130 | } |
| 1131 | |
Michael Ernst | fd0457a | 2010-08-09 18:12:50 +0200 | [diff] [blame] | 1132 | int chsc_siosl(struct subchannel_id schid) |
| 1133 | { |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1134 | struct { |
| 1135 | struct chsc_header request; |
| 1136 | u32 word1; |
| 1137 | struct subchannel_id sid; |
| 1138 | u32 word3; |
| 1139 | struct chsc_header response; |
| 1140 | u32 word[11]; |
| 1141 | } __attribute__ ((packed)) *siosl_area; |
Michael Ernst | fd0457a | 2010-08-09 18:12:50 +0200 | [diff] [blame] | 1142 | unsigned long flags; |
| 1143 | int ccode; |
| 1144 | int rc; |
| 1145 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1146 | spin_lock_irqsave(&chsc_page_lock, flags); |
| 1147 | memset(chsc_page, 0, PAGE_SIZE); |
| 1148 | siosl_area = chsc_page; |
| 1149 | siosl_area->request.length = 0x0010; |
| 1150 | siosl_area->request.code = 0x0046; |
| 1151 | siosl_area->word1 = 0x80000000; |
| 1152 | siosl_area->sid = schid; |
Michael Ernst | fd0457a | 2010-08-09 18:12:50 +0200 | [diff] [blame] | 1153 | |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1154 | ccode = chsc(siosl_area); |
Michael Ernst | fd0457a | 2010-08-09 18:12:50 +0200 | [diff] [blame] | 1155 | if (ccode > 0) { |
| 1156 | if (ccode == 3) |
| 1157 | rc = -ENODEV; |
| 1158 | else |
| 1159 | rc = -EBUSY; |
| 1160 | CIO_MSG_EVENT(2, "chsc: chsc failed for 0.%x.%04x (ccode=%d)\n", |
| 1161 | schid.ssid, schid.sch_no, ccode); |
| 1162 | goto out; |
| 1163 | } |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1164 | rc = chsc_error_from_response(siosl_area->response.code); |
Michael Ernst | fd0457a | 2010-08-09 18:12:50 +0200 | [diff] [blame] | 1165 | if (rc) |
| 1166 | CIO_MSG_EVENT(2, "chsc: siosl failed for 0.%x.%04x (rc=%04x)\n", |
| 1167 | schid.ssid, schid.sch_no, |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1168 | siosl_area->response.code); |
Michael Ernst | fd0457a | 2010-08-09 18:12:50 +0200 | [diff] [blame] | 1169 | else |
| 1170 | CIO_MSG_EVENT(4, "chsc: siosl succeeded for 0.%x.%04x\n", |
| 1171 | schid.ssid, schid.sch_no); |
| 1172 | out: |
Sebastian Ott | 34196f8 | 2010-10-25 16:10:29 +0200 | [diff] [blame] | 1173 | spin_unlock_irqrestore(&chsc_page_lock, flags); |
Michael Ernst | fd0457a | 2010-08-09 18:12:50 +0200 | [diff] [blame] | 1174 | return rc; |
| 1175 | } |
| 1176 | EXPORT_SYMBOL_GPL(chsc_siosl); |
Sebastian Ott | 184b08a | 2012-08-28 16:45:42 +0200 | [diff] [blame] | 1177 | |
| 1178 | /** |
| 1179 | * chsc_scm_info() - store SCM information (SSI) |
| 1180 | * @scm_area: request and response block for SSI |
| 1181 | * @token: continuation token |
| 1182 | * |
| 1183 | * Returns 0 on success. |
| 1184 | */ |
| 1185 | int chsc_scm_info(struct chsc_scm_info *scm_area, u64 token) |
| 1186 | { |
| 1187 | int ccode, ret; |
| 1188 | |
| 1189 | memset(scm_area, 0, sizeof(*scm_area)); |
| 1190 | scm_area->request.length = 0x0020; |
| 1191 | scm_area->request.code = 0x004C; |
| 1192 | scm_area->reqtok = token; |
| 1193 | |
| 1194 | ccode = chsc(scm_area); |
| 1195 | if (ccode > 0) { |
| 1196 | ret = (ccode == 3) ? -ENODEV : -EBUSY; |
| 1197 | goto out; |
| 1198 | } |
| 1199 | ret = chsc_error_from_response(scm_area->response.code); |
| 1200 | if (ret != 0) |
| 1201 | CIO_MSG_EVENT(2, "chsc: scm info failed (rc=%04x)\n", |
| 1202 | scm_area->response.code); |
| 1203 | out: |
| 1204 | return ret; |
| 1205 | } |
| 1206 | EXPORT_SYMBOL_GPL(chsc_scm_info); |
Eugene Crosser | 1c59a86 | 2013-04-24 12:00:23 +0200 | [diff] [blame] | 1207 | |
| 1208 | /** |
| 1209 | * chsc_pnso_brinfo() - Perform Network-Subchannel Operation, Bridge Info. |
| 1210 | * @schid: id of the subchannel on which PNSO is performed |
| 1211 | * @brinfo_area: request and response block for the operation |
| 1212 | * @resume_token: resume token for multiblock response |
| 1213 | * @cnc: Boolean change-notification control |
| 1214 | * |
| 1215 | * brinfo_area must be allocated by the caller with get_zeroed_page(GFP_KERNEL) |
| 1216 | * |
| 1217 | * Returns 0 on success. |
| 1218 | */ |
| 1219 | int chsc_pnso_brinfo(struct subchannel_id schid, |
| 1220 | struct chsc_pnso_area *brinfo_area, |
| 1221 | struct chsc_brinfo_resume_token resume_token, |
| 1222 | int cnc) |
| 1223 | { |
| 1224 | memset(brinfo_area, 0, sizeof(*brinfo_area)); |
| 1225 | brinfo_area->request.length = 0x0030; |
| 1226 | brinfo_area->request.code = 0x003d; /* network-subchannel operation */ |
| 1227 | brinfo_area->m = schid.m; |
| 1228 | brinfo_area->ssid = schid.ssid; |
| 1229 | brinfo_area->sch = schid.sch_no; |
| 1230 | brinfo_area->cssid = schid.cssid; |
| 1231 | brinfo_area->oc = 0; /* Store-network-bridging-information list */ |
| 1232 | brinfo_area->resume_token = resume_token; |
| 1233 | brinfo_area->n = (cnc != 0); |
| 1234 | if (chsc(brinfo_area)) |
| 1235 | return -EIO; |
| 1236 | return chsc_error_from_response(brinfo_area->response.code); |
| 1237 | } |
| 1238 | EXPORT_SYMBOL_GPL(chsc_pnso_brinfo); |