chsc.c 36 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615
  1. /*
  2. * drivers/s390/cio/chsc.c
  3. * S/390 common I/O routines -- channel subsystem call
  4. *
  5. * Copyright (C) 1999-2002 IBM Deutschland Entwicklung GmbH,
  6. * IBM Corporation
  7. * Author(s): Ingo Adlung (adlung@de.ibm.com)
  8. * Cornelia Huck (cornelia.huck@de.ibm.com)
  9. * Arnd Bergmann (arndb@de.ibm.com)
  10. */
  11. #include <linux/module.h>
  12. #include <linux/slab.h>
  13. #include <linux/init.h>
  14. #include <linux/device.h>
  15. #include <asm/cio.h>
  16. #include "css.h"
  17. #include "cio.h"
  18. #include "cio_debug.h"
  19. #include "ioasm.h"
  20. #include "chsc.h"
  21. static void *sei_page;
  22. static int new_channel_path(int chpid);
  23. static inline void
  24. set_chp_logically_online(int chp, int onoff)
  25. {
  26. css[0]->chps[chp]->state = onoff;
  27. }
  28. static int
  29. get_chp_status(int chp)
  30. {
  31. return (css[0]->chps[chp] ? css[0]->chps[chp]->state : -ENODEV);
  32. }
  33. void
  34. chsc_validate_chpids(struct subchannel *sch)
  35. {
  36. int mask, chp;
  37. for (chp = 0; chp <= 7; chp++) {
  38. mask = 0x80 >> chp;
  39. if (!get_chp_status(sch->schib.pmcw.chpid[chp]))
  40. /* disable using this path */
  41. sch->opm &= ~mask;
  42. }
  43. }
  44. void
  45. chpid_is_actually_online(int chp)
  46. {
  47. int state;
  48. state = get_chp_status(chp);
  49. if (state < 0) {
  50. need_rescan = 1;
  51. queue_work(slow_path_wq, &slow_path_work);
  52. } else
  53. WARN_ON(!state);
  54. }
  55. /* FIXME: this is _always_ called for every subchannel. shouldn't we
  56. * process more than one at a time? */
  57. static int
  58. chsc_get_sch_desc_irq(struct subchannel *sch, void *page)
  59. {
  60. int ccode, j;
  61. struct {
  62. struct chsc_header request;
  63. u16 reserved1a:10;
  64. u16 ssid:2;
  65. u16 reserved1b:4;
  66. u16 f_sch; /* first subchannel */
  67. u16 reserved2;
  68. u16 l_sch; /* last subchannel */
  69. u32 reserved3;
  70. struct chsc_header response;
  71. u32 reserved4;
  72. u8 sch_valid : 1;
  73. u8 dev_valid : 1;
  74. u8 st : 3; /* subchannel type */
  75. u8 zeroes : 3;
  76. u8 unit_addr; /* unit address */
  77. u16 devno; /* device number */
  78. u8 path_mask;
  79. u8 fla_valid_mask;
  80. u16 sch; /* subchannel */
  81. u8 chpid[8]; /* chpids 0-7 */
  82. u16 fla[8]; /* full link addresses 0-7 */
  83. } *ssd_area;
  84. ssd_area = page;
  85. ssd_area->request.length = 0x0010;
  86. ssd_area->request.code = 0x0004;
  87. ssd_area->ssid = sch->schid.ssid;
  88. ssd_area->f_sch = sch->schid.sch_no;
  89. ssd_area->l_sch = sch->schid.sch_no;
  90. ccode = chsc(ssd_area);
  91. if (ccode > 0) {
  92. pr_debug("chsc returned with ccode = %d\n", ccode);
  93. return (ccode == 3) ? -ENODEV : -EBUSY;
  94. }
  95. switch (ssd_area->response.code) {
  96. case 0x0001: /* everything ok */
  97. break;
  98. case 0x0002:
  99. CIO_CRW_EVENT(2, "Invalid command!\n");
  100. return -EINVAL;
  101. case 0x0003:
  102. CIO_CRW_EVENT(2, "Error in chsc request block!\n");
  103. return -EINVAL;
  104. case 0x0004:
  105. CIO_CRW_EVENT(2, "Model does not provide ssd\n");
  106. return -EOPNOTSUPP;
  107. default:
  108. CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
  109. ssd_area->response.code);
  110. return -EIO;
  111. }
  112. /*
  113. * ssd_area->st stores the type of the detected
  114. * subchannel, with the following definitions:
  115. *
  116. * 0: I/O subchannel: All fields have meaning
  117. * 1: CHSC subchannel: Only sch_val, st and sch
  118. * have meaning
  119. * 2: Message subchannel: All fields except unit_addr
  120. * have meaning
  121. * 3: ADM subchannel: Only sch_val, st and sch
  122. * have meaning
  123. *
  124. * Other types are currently undefined.
  125. */
  126. if (ssd_area->st > 3) { /* uhm, that looks strange... */
  127. CIO_CRW_EVENT(0, "Strange subchannel type %d"
  128. " for sch 0.%x.%04x\n", ssd_area->st,
  129. sch->schid.ssid, sch->schid.sch_no);
  130. /*
  131. * There may have been a new subchannel type defined in the
  132. * time since this code was written; since we don't know which
  133. * fields have meaning and what to do with it we just jump out
  134. */
  135. return 0;
  136. } else {
  137. const char *type[4] = {"I/O", "chsc", "message", "ADM"};
  138. CIO_CRW_EVENT(6, "ssd: sch 0.%x.%04x is %s subchannel\n",
  139. sch->schid.ssid, sch->schid.sch_no,
  140. type[ssd_area->st]);
  141. sch->ssd_info.valid = 1;
  142. sch->ssd_info.type = ssd_area->st;
  143. }
  144. if (ssd_area->st == 0 || ssd_area->st == 2) {
  145. for (j = 0; j < 8; j++) {
  146. if (!((0x80 >> j) & ssd_area->path_mask &
  147. ssd_area->fla_valid_mask))
  148. continue;
  149. sch->ssd_info.chpid[j] = ssd_area->chpid[j];
  150. sch->ssd_info.fla[j] = ssd_area->fla[j];
  151. }
  152. }
  153. return 0;
  154. }
  155. int
  156. css_get_ssd_info(struct subchannel *sch)
  157. {
  158. int ret;
  159. void *page;
  160. page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
  161. if (!page)
  162. return -ENOMEM;
  163. spin_lock_irq(&sch->lock);
  164. ret = chsc_get_sch_desc_irq(sch, page);
  165. if (ret) {
  166. static int cio_chsc_err_msg;
  167. if (!cio_chsc_err_msg) {
  168. printk(KERN_ERR
  169. "chsc_get_sch_descriptions:"
  170. " Error %d while doing chsc; "
  171. "processing some machine checks may "
  172. "not work\n", ret);
  173. cio_chsc_err_msg = 1;
  174. }
  175. }
  176. spin_unlock_irq(&sch->lock);
  177. free_page((unsigned long)page);
  178. if (!ret) {
  179. int j, chpid;
  180. /* Allocate channel path structures, if needed. */
  181. for (j = 0; j < 8; j++) {
  182. chpid = sch->ssd_info.chpid[j];
  183. if (chpid && (get_chp_status(chpid) < 0))
  184. new_channel_path(chpid);
  185. }
  186. }
  187. return ret;
  188. }
  189. static int
  190. s390_subchannel_remove_chpid(struct device *dev, void *data)
  191. {
  192. int j;
  193. int mask;
  194. struct subchannel *sch;
  195. struct channel_path *chpid;
  196. struct schib schib;
  197. sch = to_subchannel(dev);
  198. chpid = data;
  199. for (j = 0; j < 8; j++)
  200. if (sch->schib.pmcw.chpid[j] == chpid->id)
  201. break;
  202. if (j >= 8)
  203. return 0;
  204. mask = 0x80 >> j;
  205. spin_lock_irq(&sch->lock);
  206. stsch(sch->schid, &schib);
  207. if (!schib.pmcw.dnv)
  208. goto out_unreg;
  209. memcpy(&sch->schib, &schib, sizeof(struct schib));
  210. /* Check for single path devices. */
  211. if (sch->schib.pmcw.pim == 0x80)
  212. goto out_unreg;
  213. if ((sch->schib.scsw.actl & SCSW_ACTL_DEVACT) &&
  214. (sch->schib.scsw.actl & SCSW_ACTL_SCHACT) &&
  215. (sch->schib.pmcw.lpum == mask)) {
  216. int cc;
  217. cc = cio_clear(sch);
  218. if (cc == -ENODEV)
  219. goto out_unreg;
  220. /* Call handler. */
  221. if (sch->driver && sch->driver->termination)
  222. sch->driver->termination(&sch->dev);
  223. goto out_unlock;
  224. }
  225. /* trigger path verification. */
  226. if (sch->driver && sch->driver->verify)
  227. sch->driver->verify(&sch->dev);
  228. else if (sch->vpm == mask)
  229. goto out_unreg;
  230. out_unlock:
  231. spin_unlock_irq(&sch->lock);
  232. return 0;
  233. out_unreg:
  234. spin_unlock_irq(&sch->lock);
  235. sch->lpm = 0;
  236. if (css_enqueue_subchannel_slow(sch->schid)) {
  237. css_clear_subchannel_slow_list();
  238. need_rescan = 1;
  239. }
  240. return 0;
  241. }
  242. static inline void
  243. s390_set_chpid_offline( __u8 chpid)
  244. {
  245. char dbf_txt[15];
  246. struct device *dev;
  247. sprintf(dbf_txt, "chpr%x", chpid);
  248. CIO_TRACE_EVENT(2, dbf_txt);
  249. if (get_chp_status(chpid) <= 0)
  250. return;
  251. dev = get_device(&css[0]->chps[chpid]->dev);
  252. bus_for_each_dev(&css_bus_type, NULL, to_channelpath(dev),
  253. s390_subchannel_remove_chpid);
  254. if (need_rescan || css_slow_subchannels_exist())
  255. queue_work(slow_path_wq, &slow_path_work);
  256. put_device(dev);
  257. }
  258. struct res_acc_data {
  259. struct channel_path *chp;
  260. u32 fla_mask;
  261. u16 fla;
  262. };
  263. static int
  264. s390_process_res_acc_sch(struct res_acc_data *res_data, struct subchannel *sch)
  265. {
  266. int found;
  267. int chp;
  268. int ccode;
  269. found = 0;
  270. for (chp = 0; chp <= 7; chp++)
  271. /*
  272. * check if chpid is in information updated by ssd
  273. */
  274. if (sch->ssd_info.valid &&
  275. sch->ssd_info.chpid[chp] == res_data->chp->id &&
  276. (sch->ssd_info.fla[chp] & res_data->fla_mask)
  277. == res_data->fla) {
  278. found = 1;
  279. break;
  280. }
  281. if (found == 0)
  282. return 0;
  283. /*
  284. * Do a stsch to update our subchannel structure with the
  285. * new path information and eventually check for logically
  286. * offline chpids.
  287. */
  288. ccode = stsch(sch->schid, &sch->schib);
  289. if (ccode > 0)
  290. return 0;
  291. return 0x80 >> chp;
  292. }
  293. static inline int
  294. s390_process_res_acc_new_sch(struct subchannel_id schid)
  295. {
  296. struct schib schib;
  297. int ret;
  298. /*
  299. * We don't know the device yet, but since a path
  300. * may be available now to the device we'll have
  301. * to do recognition again.
  302. * Since we don't have any idea about which chpid
  303. * that beast may be on we'll have to do a stsch
  304. * on all devices, grr...
  305. */
  306. if (stsch_err(schid, &schib))
  307. /* We're through */
  308. return need_rescan ? -EAGAIN : -ENXIO;
  309. /* Put it on the slow path. */
  310. ret = css_enqueue_subchannel_slow(schid);
  311. if (ret) {
  312. css_clear_subchannel_slow_list();
  313. need_rescan = 1;
  314. return -EAGAIN;
  315. }
  316. return 0;
  317. }
  318. static int
  319. __s390_process_res_acc(struct subchannel_id schid, void *data)
  320. {
  321. int chp_mask, old_lpm;
  322. struct res_acc_data *res_data;
  323. struct subchannel *sch;
  324. res_data = (struct res_acc_data *)data;
  325. sch = get_subchannel_by_schid(schid);
  326. if (!sch)
  327. /* Check if a subchannel is newly available. */
  328. return s390_process_res_acc_new_sch(schid);
  329. spin_lock_irq(&sch->lock);
  330. chp_mask = s390_process_res_acc_sch(res_data, sch);
  331. if (chp_mask == 0) {
  332. spin_unlock_irq(&sch->lock);
  333. return 0;
  334. }
  335. old_lpm = sch->lpm;
  336. sch->lpm = ((sch->schib.pmcw.pim &
  337. sch->schib.pmcw.pam &
  338. sch->schib.pmcw.pom)
  339. | chp_mask) & sch->opm;
  340. if (!old_lpm && sch->lpm)
  341. device_trigger_reprobe(sch);
  342. else if (sch->driver && sch->driver->verify)
  343. sch->driver->verify(&sch->dev);
  344. spin_unlock_irq(&sch->lock);
  345. put_device(&sch->dev);
  346. return (res_data->fla_mask == 0xffff) ? -ENODEV : 0;
  347. }
  348. static int
  349. s390_process_res_acc (struct res_acc_data *res_data)
  350. {
  351. int rc;
  352. char dbf_txt[15];
  353. sprintf(dbf_txt, "accpr%x", res_data->chp->id);
  354. CIO_TRACE_EVENT( 2, dbf_txt);
  355. if (res_data->fla != 0) {
  356. sprintf(dbf_txt, "fla%x", res_data->fla);
  357. CIO_TRACE_EVENT( 2, dbf_txt);
  358. }
  359. /*
  360. * I/O resources may have become accessible.
  361. * Scan through all subchannels that may be concerned and
  362. * do a validation on those.
  363. * The more information we have (info), the less scanning
  364. * will we have to do.
  365. */
  366. rc = for_each_subchannel(__s390_process_res_acc, res_data);
  367. if (css_slow_subchannels_exist())
  368. rc = -EAGAIN;
  369. else if (rc != -EAGAIN)
  370. rc = 0;
  371. return rc;
  372. }
  373. static int
  374. __get_chpid_from_lir(void *data)
  375. {
  376. struct lir {
  377. u8 iq;
  378. u8 ic;
  379. u16 sci;
  380. /* incident-node descriptor */
  381. u32 indesc[28];
  382. /* attached-node descriptor */
  383. u32 andesc[28];
  384. /* incident-specific information */
  385. u32 isinfo[28];
  386. } *lir;
  387. lir = (struct lir*) data;
  388. if (!(lir->iq&0x80))
  389. /* NULL link incident record */
  390. return -EINVAL;
  391. if (!(lir->indesc[0]&0xc0000000))
  392. /* node descriptor not valid */
  393. return -EINVAL;
  394. if (!(lir->indesc[0]&0x10000000))
  395. /* don't handle device-type nodes - FIXME */
  396. return -EINVAL;
  397. /* Byte 3 contains the chpid. Could also be CTCA, but we don't care */
  398. return (u16) (lir->indesc[0]&0x000000ff);
  399. }
  400. int
  401. chsc_process_crw(void)
  402. {
  403. int chpid, ret;
  404. struct res_acc_data res_data;
  405. struct {
  406. struct chsc_header request;
  407. u32 reserved1;
  408. u32 reserved2;
  409. u32 reserved3;
  410. struct chsc_header response;
  411. u32 reserved4;
  412. u8 flags;
  413. u8 vf; /* validity flags */
  414. u8 rs; /* reporting source */
  415. u8 cc; /* content code */
  416. u16 fla; /* full link address */
  417. u16 rsid; /* reporting source id */
  418. u32 reserved5;
  419. u32 reserved6;
  420. u32 ccdf[96]; /* content-code dependent field */
  421. /* ccdf has to be big enough for a link-incident record */
  422. } *sei_area;
  423. if (!sei_page)
  424. return 0;
  425. /*
  426. * build the chsc request block for store event information
  427. * and do the call
  428. * This function is only called by the machine check handler thread,
  429. * so we don't need locking for the sei_page.
  430. */
  431. sei_area = sei_page;
  432. CIO_TRACE_EVENT( 2, "prcss");
  433. ret = 0;
  434. do {
  435. int ccode, status;
  436. struct device *dev;
  437. memset(sei_area, 0, sizeof(*sei_area));
  438. memset(&res_data, 0, sizeof(struct res_acc_data));
  439. sei_area->request.length = 0x0010;
  440. sei_area->request.code = 0x000e;
  441. ccode = chsc(sei_area);
  442. if (ccode > 0)
  443. return 0;
  444. switch (sei_area->response.code) {
  445. /* for debug purposes, check for problems */
  446. case 0x0001:
  447. CIO_CRW_EVENT(4, "chsc_process_crw: event information "
  448. "successfully stored\n");
  449. break; /* everything ok */
  450. case 0x0002:
  451. CIO_CRW_EVENT(2,
  452. "chsc_process_crw: invalid command!\n");
  453. return 0;
  454. case 0x0003:
  455. CIO_CRW_EVENT(2, "chsc_process_crw: error in chsc "
  456. "request block!\n");
  457. return 0;
  458. case 0x0005:
  459. CIO_CRW_EVENT(2, "chsc_process_crw: no event "
  460. "information stored\n");
  461. return 0;
  462. default:
  463. CIO_CRW_EVENT(2, "chsc_process_crw: chsc response %d\n",
  464. sei_area->response.code);
  465. return 0;
  466. }
  467. /* Check if we might have lost some information. */
  468. if (sei_area->flags & 0x40)
  469. CIO_CRW_EVENT(2, "chsc_process_crw: Event information "
  470. "has been lost due to overflow!\n");
  471. if (sei_area->rs != 4) {
  472. CIO_CRW_EVENT(2, "chsc_process_crw: reporting source "
  473. "(%04X) isn't a chpid!\n",
  474. sei_area->rsid);
  475. continue;
  476. }
  477. /* which kind of information was stored? */
  478. switch (sei_area->cc) {
  479. case 1: /* link incident*/
  480. CIO_CRW_EVENT(4, "chsc_process_crw: "
  481. "channel subsystem reports link incident,"
  482. " reporting source is chpid %x\n",
  483. sei_area->rsid);
  484. chpid = __get_chpid_from_lir(sei_area->ccdf);
  485. if (chpid < 0)
  486. CIO_CRW_EVENT(4, "%s: Invalid LIR, skipping\n",
  487. __FUNCTION__);
  488. else
  489. s390_set_chpid_offline(chpid);
  490. break;
  491. case 2: /* i/o resource accessibiliy */
  492. CIO_CRW_EVENT(4, "chsc_process_crw: "
  493. "channel subsystem reports some I/O "
  494. "devices may have become accessible\n");
  495. pr_debug("Data received after sei: \n");
  496. pr_debug("Validity flags: %x\n", sei_area->vf);
  497. /* allocate a new channel path structure, if needed */
  498. status = get_chp_status(sei_area->rsid);
  499. if (status < 0)
  500. new_channel_path(sei_area->rsid);
  501. else if (!status)
  502. break;
  503. dev = get_device(&css[0]->chps[sei_area->rsid]->dev);
  504. res_data.chp = to_channelpath(dev);
  505. pr_debug("chpid: %x", sei_area->rsid);
  506. if ((sei_area->vf & 0xc0) != 0) {
  507. res_data.fla = sei_area->fla;
  508. if ((sei_area->vf & 0xc0) == 0xc0) {
  509. pr_debug(" full link addr: %x",
  510. sei_area->fla);
  511. res_data.fla_mask = 0xffff;
  512. } else {
  513. pr_debug(" link addr: %x",
  514. sei_area->fla);
  515. res_data.fla_mask = 0xff00;
  516. }
  517. }
  518. ret = s390_process_res_acc(&res_data);
  519. pr_debug("\n\n");
  520. put_device(dev);
  521. break;
  522. default: /* other stuff */
  523. CIO_CRW_EVENT(4, "chsc_process_crw: event %d\n",
  524. sei_area->cc);
  525. break;
  526. }
  527. } while (sei_area->flags & 0x80);
  528. return ret;
  529. }
  530. static inline int
  531. __chp_add_new_sch(struct subchannel_id schid)
  532. {
  533. struct schib schib;
  534. int ret;
  535. if (stsch(schid, &schib))
  536. /* We're through */
  537. return need_rescan ? -EAGAIN : -ENXIO;
  538. /* Put it on the slow path. */
  539. ret = css_enqueue_subchannel_slow(schid);
  540. if (ret) {
  541. css_clear_subchannel_slow_list();
  542. need_rescan = 1;
  543. return -EAGAIN;
  544. }
  545. return 0;
  546. }
  547. static int
  548. __chp_add(struct subchannel_id schid, void *data)
  549. {
  550. int i;
  551. struct channel_path *chp;
  552. struct subchannel *sch;
  553. chp = (struct channel_path *)data;
  554. sch = get_subchannel_by_schid(schid);
  555. if (!sch)
  556. /* Check if the subchannel is now available. */
  557. return __chp_add_new_sch(schid);
  558. spin_lock_irq(&sch->lock);
  559. for (i=0; i<8; i++)
  560. if (sch->schib.pmcw.chpid[i] == chp->id) {
  561. if (stsch(sch->schid, &sch->schib) != 0) {
  562. /* Endgame. */
  563. spin_unlock_irq(&sch->lock);
  564. return -ENXIO;
  565. }
  566. break;
  567. }
  568. if (i==8) {
  569. spin_unlock_irq(&sch->lock);
  570. return 0;
  571. }
  572. sch->lpm = ((sch->schib.pmcw.pim &
  573. sch->schib.pmcw.pam &
  574. sch->schib.pmcw.pom)
  575. | 0x80 >> i) & sch->opm;
  576. if (sch->driver && sch->driver->verify)
  577. sch->driver->verify(&sch->dev);
  578. spin_unlock_irq(&sch->lock);
  579. put_device(&sch->dev);
  580. return 0;
  581. }
  582. static int
  583. chp_add(int chpid)
  584. {
  585. int rc;
  586. char dbf_txt[15];
  587. struct device *dev;
  588. if (!get_chp_status(chpid))
  589. return 0; /* no need to do the rest */
  590. sprintf(dbf_txt, "cadd%x", chpid);
  591. CIO_TRACE_EVENT(2, dbf_txt);
  592. dev = get_device(&css[0]->chps[chpid]->dev);
  593. rc = for_each_subchannel(__chp_add, to_channelpath(dev));
  594. if (css_slow_subchannels_exist())
  595. rc = -EAGAIN;
  596. if (rc != -EAGAIN)
  597. rc = 0;
  598. put_device(dev);
  599. return rc;
  600. }
  601. /*
  602. * Handling of crw machine checks with channel path source.
  603. */
  604. int
  605. chp_process_crw(int chpid, int on)
  606. {
  607. if (on == 0) {
  608. /* Path has gone. We use the link incident routine.*/
  609. s390_set_chpid_offline(chpid);
  610. return 0; /* De-register is async anyway. */
  611. }
  612. /*
  613. * Path has come. Allocate a new channel path structure,
  614. * if needed.
  615. */
  616. if (get_chp_status(chpid) < 0)
  617. new_channel_path(chpid);
  618. /* Avoid the extra overhead in process_rec_acc. */
  619. return chp_add(chpid);
  620. }
  621. static inline int
  622. __check_for_io_and_kill(struct subchannel *sch, int index)
  623. {
  624. int cc;
  625. if (!device_is_online(sch))
  626. /* cio could be doing I/O. */
  627. return 0;
  628. cc = stsch(sch->schid, &sch->schib);
  629. if (cc)
  630. return 0;
  631. if (sch->schib.scsw.actl && sch->schib.pmcw.lpum == (0x80 >> index)) {
  632. device_set_waiting(sch);
  633. return 1;
  634. }
  635. return 0;
  636. }
  637. static inline void
  638. __s390_subchannel_vary_chpid(struct subchannel *sch, __u8 chpid, int on)
  639. {
  640. int chp, old_lpm;
  641. unsigned long flags;
  642. if (!sch->ssd_info.valid)
  643. return;
  644. spin_lock_irqsave(&sch->lock, flags);
  645. old_lpm = sch->lpm;
  646. for (chp = 0; chp < 8; chp++) {
  647. if (sch->ssd_info.chpid[chp] != chpid)
  648. continue;
  649. if (on) {
  650. sch->opm |= (0x80 >> chp);
  651. sch->lpm |= (0x80 >> chp);
  652. if (!old_lpm)
  653. device_trigger_reprobe(sch);
  654. else if (sch->driver && sch->driver->verify)
  655. sch->driver->verify(&sch->dev);
  656. } else {
  657. sch->opm &= ~(0x80 >> chp);
  658. sch->lpm &= ~(0x80 >> chp);
  659. /*
  660. * Give running I/O a grace period in which it
  661. * can successfully terminate, even using the
  662. * just varied off path. Then kill it.
  663. */
  664. if (!__check_for_io_and_kill(sch, chp) && !sch->lpm) {
  665. if (css_enqueue_subchannel_slow(sch->schid)) {
  666. css_clear_subchannel_slow_list();
  667. need_rescan = 1;
  668. }
  669. } else if (sch->driver && sch->driver->verify)
  670. sch->driver->verify(&sch->dev);
  671. }
  672. break;
  673. }
  674. spin_unlock_irqrestore(&sch->lock, flags);
  675. }
  676. static int
  677. s390_subchannel_vary_chpid_off(struct device *dev, void *data)
  678. {
  679. struct subchannel *sch;
  680. __u8 *chpid;
  681. sch = to_subchannel(dev);
  682. chpid = data;
  683. __s390_subchannel_vary_chpid(sch, *chpid, 0);
  684. return 0;
  685. }
  686. static int
  687. s390_subchannel_vary_chpid_on(struct device *dev, void *data)
  688. {
  689. struct subchannel *sch;
  690. __u8 *chpid;
  691. sch = to_subchannel(dev);
  692. chpid = data;
  693. __s390_subchannel_vary_chpid(sch, *chpid, 1);
  694. return 0;
  695. }
  696. static int
  697. __s390_vary_chpid_on(struct subchannel_id schid, void *data)
  698. {
  699. struct schib schib;
  700. struct subchannel *sch;
  701. sch = get_subchannel_by_schid(schid);
  702. if (sch) {
  703. put_device(&sch->dev);
  704. return 0;
  705. }
  706. if (stsch_err(schid, &schib))
  707. /* We're through */
  708. return -ENXIO;
  709. /* Put it on the slow path. */
  710. if (css_enqueue_subchannel_slow(schid)) {
  711. css_clear_subchannel_slow_list();
  712. need_rescan = 1;
  713. return -EAGAIN;
  714. }
  715. return 0;
  716. }
  717. /*
  718. * Function: s390_vary_chpid
  719. * Varies the specified chpid online or offline
  720. */
  721. static int
  722. s390_vary_chpid( __u8 chpid, int on)
  723. {
  724. char dbf_text[15];
  725. int status;
  726. sprintf(dbf_text, on?"varyon%x":"varyoff%x", chpid);
  727. CIO_TRACE_EVENT( 2, dbf_text);
  728. status = get_chp_status(chpid);
  729. if (status < 0) {
  730. printk(KERN_ERR "Can't vary unknown chpid %02X\n", chpid);
  731. return -EINVAL;
  732. }
  733. if (!on && !status) {
  734. printk(KERN_ERR "chpid %x is already offline\n", chpid);
  735. return -EINVAL;
  736. }
  737. set_chp_logically_online(chpid, on);
  738. /*
  739. * Redo PathVerification on the devices the chpid connects to
  740. */
  741. bus_for_each_dev(&css_bus_type, NULL, &chpid, on ?
  742. s390_subchannel_vary_chpid_on :
  743. s390_subchannel_vary_chpid_off);
  744. if (on)
  745. /* Scan for new devices on varied on path. */
  746. for_each_subchannel(__s390_vary_chpid_on, NULL);
  747. if (need_rescan || css_slow_subchannels_exist())
  748. queue_work(slow_path_wq, &slow_path_work);
  749. return 0;
  750. }
  751. /*
  752. * Channel measurement related functions
  753. */
  754. static ssize_t
  755. chp_measurement_chars_read(struct kobject *kobj, char *buf, loff_t off,
  756. size_t count)
  757. {
  758. struct channel_path *chp;
  759. unsigned int size;
  760. chp = to_channelpath(container_of(kobj, struct device, kobj));
  761. if (!chp->cmg_chars)
  762. return 0;
  763. size = sizeof(struct cmg_chars);
  764. if (off > size)
  765. return 0;
  766. if (off + count > size)
  767. count = size - off;
  768. memcpy(buf, chp->cmg_chars + off, count);
  769. return count;
  770. }
  771. static struct bin_attribute chp_measurement_chars_attr = {
  772. .attr = {
  773. .name = "measurement_chars",
  774. .mode = S_IRUSR,
  775. .owner = THIS_MODULE,
  776. },
  777. .size = sizeof(struct cmg_chars),
  778. .read = chp_measurement_chars_read,
  779. };
  780. static void
  781. chp_measurement_copy_block(struct cmg_entry *buf,
  782. struct channel_subsystem *css, int chpid)
  783. {
  784. void *area;
  785. struct cmg_entry *entry, reference_buf;
  786. int idx;
  787. if (chpid < 128) {
  788. area = css->cub_addr1;
  789. idx = chpid;
  790. } else {
  791. area = css->cub_addr2;
  792. idx = chpid - 128;
  793. }
  794. entry = area + (idx * sizeof(struct cmg_entry));
  795. do {
  796. memcpy(buf, entry, sizeof(*entry));
  797. memcpy(&reference_buf, entry, sizeof(*entry));
  798. } while (reference_buf.values[0] != buf->values[0]);
  799. }
  800. static ssize_t
  801. chp_measurement_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
  802. {
  803. struct channel_path *chp;
  804. struct channel_subsystem *css;
  805. unsigned int size;
  806. chp = to_channelpath(container_of(kobj, struct device, kobj));
  807. css = to_css(chp->dev.parent);
  808. size = sizeof(struct cmg_entry);
  809. /* Only allow single reads. */
  810. if (off || count < size)
  811. return 0;
  812. chp_measurement_copy_block((struct cmg_entry *)buf, css, chp->id);
  813. count = size;
  814. return count;
  815. }
  816. static struct bin_attribute chp_measurement_attr = {
  817. .attr = {
  818. .name = "measurement",
  819. .mode = S_IRUSR,
  820. .owner = THIS_MODULE,
  821. },
  822. .size = sizeof(struct cmg_entry),
  823. .read = chp_measurement_read,
  824. };
  825. static void
  826. chsc_remove_chp_cmg_attr(struct channel_path *chp)
  827. {
  828. sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_chars_attr);
  829. sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_attr);
  830. }
  831. static int
  832. chsc_add_chp_cmg_attr(struct channel_path *chp)
  833. {
  834. int ret;
  835. ret = sysfs_create_bin_file(&chp->dev.kobj,
  836. &chp_measurement_chars_attr);
  837. if (ret)
  838. return ret;
  839. ret = sysfs_create_bin_file(&chp->dev.kobj, &chp_measurement_attr);
  840. if (ret)
  841. sysfs_remove_bin_file(&chp->dev.kobj,
  842. &chp_measurement_chars_attr);
  843. return ret;
  844. }
  845. static void
  846. chsc_remove_cmg_attr(struct channel_subsystem *css)
  847. {
  848. int i;
  849. for (i = 0; i <= __MAX_CHPID; i++) {
  850. if (!css->chps[i])
  851. continue;
  852. chsc_remove_chp_cmg_attr(css->chps[i]);
  853. }
  854. }
  855. static int
  856. chsc_add_cmg_attr(struct channel_subsystem *css)
  857. {
  858. int i, ret;
  859. ret = 0;
  860. for (i = 0; i <= __MAX_CHPID; i++) {
  861. if (!css->chps[i])
  862. continue;
  863. ret = chsc_add_chp_cmg_attr(css->chps[i]);
  864. if (ret)
  865. goto cleanup;
  866. }
  867. return ret;
  868. cleanup:
  869. for (--i; i >= 0; i--) {
  870. if (!css->chps[i])
  871. continue;
  872. chsc_remove_chp_cmg_attr(css->chps[i]);
  873. }
  874. return ret;
  875. }
  876. static int
  877. __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
  878. {
  879. struct {
  880. struct chsc_header request;
  881. u32 operation_code : 2;
  882. u32 : 30;
  883. u32 key : 4;
  884. u32 : 28;
  885. u32 zeroes1;
  886. u32 cub_addr1;
  887. u32 zeroes2;
  888. u32 cub_addr2;
  889. u32 reserved[13];
  890. struct chsc_header response;
  891. u32 status : 8;
  892. u32 : 4;
  893. u32 fmt : 4;
  894. u32 : 16;
  895. } *secm_area;
  896. int ret, ccode;
  897. secm_area = page;
  898. secm_area->request.length = 0x0050;
  899. secm_area->request.code = 0x0016;
  900. secm_area->key = PAGE_DEFAULT_KEY;
  901. secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;
  902. secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;
  903. secm_area->operation_code = enable ? 0 : 1;
  904. ccode = chsc(secm_area);
  905. if (ccode > 0)
  906. return (ccode == 3) ? -ENODEV : -EBUSY;
  907. switch (secm_area->response.code) {
  908. case 0x0001: /* Success. */
  909. ret = 0;
  910. break;
  911. case 0x0003: /* Invalid block. */
  912. case 0x0007: /* Invalid format. */
  913. case 0x0008: /* Other invalid block. */
  914. CIO_CRW_EVENT(2, "Error in chsc request block!\n");
  915. ret = -EINVAL;
  916. break;
  917. case 0x0004: /* Command not provided in model. */
  918. CIO_CRW_EVENT(2, "Model does not provide secm\n");
  919. ret = -EOPNOTSUPP;
  920. break;
  921. case 0x0102: /* cub adresses incorrect */
  922. CIO_CRW_EVENT(2, "Invalid addresses in chsc request block\n");
  923. ret = -EINVAL;
  924. break;
  925. case 0x0103: /* key error */
  926. CIO_CRW_EVENT(2, "Access key error in secm\n");
  927. ret = -EINVAL;
  928. break;
  929. case 0x0105: /* error while starting */
  930. CIO_CRW_EVENT(2, "Error while starting channel measurement\n");
  931. ret = -EIO;
  932. break;
  933. default:
  934. CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
  935. secm_area->response.code);
  936. ret = -EIO;
  937. }
  938. return ret;
  939. }
  940. int
  941. chsc_secm(struct channel_subsystem *css, int enable)
  942. {
  943. void *secm_area;
  944. int ret;
  945. secm_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
  946. if (!secm_area)
  947. return -ENOMEM;
  948. mutex_lock(&css->mutex);
  949. if (enable && !css->cm_enabled) {
  950. css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
  951. css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
  952. if (!css->cub_addr1 || !css->cub_addr2) {
  953. free_page((unsigned long)css->cub_addr1);
  954. free_page((unsigned long)css->cub_addr2);
  955. free_page((unsigned long)secm_area);
  956. mutex_unlock(&css->mutex);
  957. return -ENOMEM;
  958. }
  959. }
  960. ret = __chsc_do_secm(css, enable, secm_area);
  961. if (!ret) {
  962. css->cm_enabled = enable;
  963. if (css->cm_enabled) {
  964. ret = chsc_add_cmg_attr(css);
  965. if (ret) {
  966. memset(secm_area, 0, PAGE_SIZE);
  967. __chsc_do_secm(css, 0, secm_area);
  968. css->cm_enabled = 0;
  969. }
  970. } else
  971. chsc_remove_cmg_attr(css);
  972. }
  973. if (enable && !css->cm_enabled) {
  974. free_page((unsigned long)css->cub_addr1);
  975. free_page((unsigned long)css->cub_addr2);
  976. }
  977. mutex_unlock(&css->mutex);
  978. free_page((unsigned long)secm_area);
  979. return ret;
  980. }
  981. /*
  982. * Files for the channel path entries.
  983. */
  984. static ssize_t
  985. chp_status_show(struct device *dev, struct device_attribute *attr, char *buf)
  986. {
  987. struct channel_path *chp = container_of(dev, struct channel_path, dev);
  988. if (!chp)
  989. return 0;
  990. return (get_chp_status(chp->id) ? sprintf(buf, "online\n") :
  991. sprintf(buf, "offline\n"));
  992. }
  993. static ssize_t
  994. chp_status_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
  995. {
  996. struct channel_path *cp = container_of(dev, struct channel_path, dev);
  997. char cmd[10];
  998. int num_args;
  999. int error;
  1000. num_args = sscanf(buf, "%5s", cmd);
  1001. if (!num_args)
  1002. return count;
  1003. if (!strnicmp(cmd, "on", 2))
  1004. error = s390_vary_chpid(cp->id, 1);
  1005. else if (!strnicmp(cmd, "off", 3))
  1006. error = s390_vary_chpid(cp->id, 0);
  1007. else
  1008. error = -EINVAL;
  1009. return error < 0 ? error : count;
  1010. }
  1011. static DEVICE_ATTR(status, 0644, chp_status_show, chp_status_write);
  1012. static ssize_t
  1013. chp_type_show(struct device *dev, struct device_attribute *attr, char *buf)
  1014. {
  1015. struct channel_path *chp = container_of(dev, struct channel_path, dev);
  1016. if (!chp)
  1017. return 0;
  1018. return sprintf(buf, "%x\n", chp->desc.desc);
  1019. }
  1020. static DEVICE_ATTR(type, 0444, chp_type_show, NULL);
  1021. static ssize_t
  1022. chp_cmg_show(struct device *dev, struct device_attribute *attr, char *buf)
  1023. {
  1024. struct channel_path *chp = to_channelpath(dev);
  1025. if (!chp)
  1026. return 0;
  1027. if (chp->cmg == -1) /* channel measurements not available */
  1028. return sprintf(buf, "unknown\n");
  1029. return sprintf(buf, "%x\n", chp->cmg);
  1030. }
  1031. static DEVICE_ATTR(cmg, 0444, chp_cmg_show, NULL);
  1032. static ssize_t
  1033. chp_shared_show(struct device *dev, struct device_attribute *attr, char *buf)
  1034. {
  1035. struct channel_path *chp = to_channelpath(dev);
  1036. if (!chp)
  1037. return 0;
  1038. if (chp->shared == -1) /* channel measurements not available */
  1039. return sprintf(buf, "unknown\n");
  1040. return sprintf(buf, "%x\n", chp->shared);
  1041. }
  1042. static DEVICE_ATTR(shared, 0444, chp_shared_show, NULL);
  1043. static struct attribute * chp_attrs[] = {
  1044. &dev_attr_status.attr,
  1045. &dev_attr_type.attr,
  1046. &dev_attr_cmg.attr,
  1047. &dev_attr_shared.attr,
  1048. NULL,
  1049. };
  1050. static struct attribute_group chp_attr_group = {
  1051. .attrs = chp_attrs,
  1052. };
  1053. static void
  1054. chp_release(struct device *dev)
  1055. {
  1056. struct channel_path *cp;
  1057. cp = container_of(dev, struct channel_path, dev);
  1058. kfree(cp);
  1059. }
  1060. static int
  1061. chsc_determine_channel_path_description(int chpid,
  1062. struct channel_path_desc *desc)
  1063. {
  1064. int ccode, ret;
  1065. struct {
  1066. struct chsc_header request;
  1067. u32 : 24;
  1068. u32 first_chpid : 8;
  1069. u32 : 24;
  1070. u32 last_chpid : 8;
  1071. u32 zeroes1;
  1072. struct chsc_header response;
  1073. u32 zeroes2;
  1074. struct channel_path_desc desc;
  1075. } *scpd_area;
  1076. scpd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
  1077. if (!scpd_area)
  1078. return -ENOMEM;
  1079. scpd_area->request.length = 0x0010;
  1080. scpd_area->request.code = 0x0002;
  1081. scpd_area->first_chpid = chpid;
  1082. scpd_area->last_chpid = chpid;
  1083. ccode = chsc(scpd_area);
  1084. if (ccode > 0) {
  1085. ret = (ccode == 3) ? -ENODEV : -EBUSY;
  1086. goto out;
  1087. }
  1088. switch (scpd_area->response.code) {
  1089. case 0x0001: /* Success. */
  1090. memcpy(desc, &scpd_area->desc,
  1091. sizeof(struct channel_path_desc));
  1092. ret = 0;
  1093. break;
  1094. case 0x0003: /* Invalid block. */
  1095. case 0x0007: /* Invalid format. */
  1096. case 0x0008: /* Other invalid block. */
  1097. CIO_CRW_EVENT(2, "Error in chsc request block!\n");
  1098. ret = -EINVAL;
  1099. break;
  1100. case 0x0004: /* Command not provided in model. */
  1101. CIO_CRW_EVENT(2, "Model does not provide scpd\n");
  1102. ret = -EOPNOTSUPP;
  1103. break;
  1104. default:
  1105. CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
  1106. scpd_area->response.code);
  1107. ret = -EIO;
  1108. }
  1109. out:
  1110. free_page((unsigned long)scpd_area);
  1111. return ret;
  1112. }
  1113. static void
  1114. chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv,
  1115. struct cmg_chars *chars)
  1116. {
  1117. switch (chp->cmg) {
  1118. case 2:
  1119. case 3:
  1120. chp->cmg_chars = kmalloc(sizeof(struct cmg_chars),
  1121. GFP_KERNEL);
  1122. if (chp->cmg_chars) {
  1123. int i, mask;
  1124. struct cmg_chars *cmg_chars;
  1125. cmg_chars = chp->cmg_chars;
  1126. for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {
  1127. mask = 0x80 >> (i + 3);
  1128. if (cmcv & mask)
  1129. cmg_chars->values[i] = chars->values[i];
  1130. else
  1131. cmg_chars->values[i] = 0;
  1132. }
  1133. }
  1134. break;
  1135. default:
  1136. /* No cmg-dependent data. */
  1137. break;
  1138. }
  1139. }
  1140. static int
  1141. chsc_get_channel_measurement_chars(struct channel_path *chp)
  1142. {
  1143. int ccode, ret;
  1144. struct {
  1145. struct chsc_header request;
  1146. u32 : 24;
  1147. u32 first_chpid : 8;
  1148. u32 : 24;
  1149. u32 last_chpid : 8;
  1150. u32 zeroes1;
  1151. struct chsc_header response;
  1152. u32 zeroes2;
  1153. u32 not_valid : 1;
  1154. u32 shared : 1;
  1155. u32 : 22;
  1156. u32 chpid : 8;
  1157. u32 cmcv : 5;
  1158. u32 : 11;
  1159. u32 cmgq : 8;
  1160. u32 cmg : 8;
  1161. u32 zeroes3;
  1162. u32 data[NR_MEASUREMENT_CHARS];
  1163. } *scmc_area;
  1164. scmc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
  1165. if (!scmc_area)
  1166. return -ENOMEM;
  1167. scmc_area->request.length = 0x0010;
  1168. scmc_area->request.code = 0x0022;
  1169. scmc_area->first_chpid = chp->id;
  1170. scmc_area->last_chpid = chp->id;
  1171. ccode = chsc(scmc_area);
  1172. if (ccode > 0) {
  1173. ret = (ccode == 3) ? -ENODEV : -EBUSY;
  1174. goto out;
  1175. }
  1176. switch (scmc_area->response.code) {
  1177. case 0x0001: /* Success. */
  1178. if (!scmc_area->not_valid) {
  1179. chp->cmg = scmc_area->cmg;
  1180. chp->shared = scmc_area->shared;
  1181. chsc_initialize_cmg_chars(chp, scmc_area->cmcv,
  1182. (struct cmg_chars *)
  1183. &scmc_area->data);
  1184. } else {
  1185. chp->cmg = -1;
  1186. chp->shared = -1;
  1187. }
  1188. ret = 0;
  1189. break;
  1190. case 0x0003: /* Invalid block. */
  1191. case 0x0007: /* Invalid format. */
  1192. case 0x0008: /* Invalid bit combination. */
  1193. CIO_CRW_EVENT(2, "Error in chsc request block!\n");
  1194. ret = -EINVAL;
  1195. break;
  1196. case 0x0004: /* Command not provided. */
  1197. CIO_CRW_EVENT(2, "Model does not provide scmc\n");
  1198. ret = -EOPNOTSUPP;
  1199. break;
  1200. default:
  1201. CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
  1202. scmc_area->response.code);
  1203. ret = -EIO;
  1204. }
  1205. out:
  1206. free_page((unsigned long)scmc_area);
  1207. return ret;
  1208. }
  1209. /*
  1210. * Entries for chpids on the system bus.
  1211. * This replaces /proc/chpids.
  1212. */
  1213. static int
  1214. new_channel_path(int chpid)
  1215. {
  1216. struct channel_path *chp;
  1217. int ret;
  1218. chp = kzalloc(sizeof(struct channel_path), GFP_KERNEL);
  1219. if (!chp)
  1220. return -ENOMEM;
  1221. /* fill in status, etc. */
  1222. chp->id = chpid;
  1223. chp->state = 1;
  1224. chp->dev.parent = &css[0]->device;
  1225. chp->dev.release = chp_release;
  1226. snprintf(chp->dev.bus_id, BUS_ID_SIZE, "chp0.%x", chpid);
  1227. /* Obtain channel path description and fill it in. */
  1228. ret = chsc_determine_channel_path_description(chpid, &chp->desc);
  1229. if (ret)
  1230. goto out_free;
  1231. /* Get channel-measurement characteristics. */
  1232. if (css_characteristics_avail && css_chsc_characteristics.scmc
  1233. && css_chsc_characteristics.secm) {
  1234. ret = chsc_get_channel_measurement_chars(chp);
  1235. if (ret)
  1236. goto out_free;
  1237. } else {
  1238. static int msg_done;
  1239. if (!msg_done) {
  1240. printk(KERN_WARNING "cio: Channel measurements not "
  1241. "available, continuing.\n");
  1242. msg_done = 1;
  1243. }
  1244. chp->cmg = -1;
  1245. }
  1246. /* make it known to the system */
  1247. ret = device_register(&chp->dev);
  1248. if (ret) {
  1249. printk(KERN_WARNING "%s: could not register %02x\n",
  1250. __func__, chpid);
  1251. goto out_free;
  1252. }
  1253. ret = sysfs_create_group(&chp->dev.kobj, &chp_attr_group);
  1254. if (ret) {
  1255. device_unregister(&chp->dev);
  1256. goto out_free;
  1257. }
  1258. mutex_lock(&css[0]->mutex);
  1259. if (css[0]->cm_enabled) {
  1260. ret = chsc_add_chp_cmg_attr(chp);
  1261. if (ret) {
  1262. sysfs_remove_group(&chp->dev.kobj, &chp_attr_group);
  1263. device_unregister(&chp->dev);
  1264. mutex_unlock(&css[0]->mutex);
  1265. goto out_free;
  1266. }
  1267. }
  1268. css[0]->chps[chpid] = chp;
  1269. mutex_unlock(&css[0]->mutex);
  1270. return ret;
  1271. out_free:
  1272. kfree(chp);
  1273. return ret;
  1274. }
  1275. void *
  1276. chsc_get_chp_desc(struct subchannel *sch, int chp_no)
  1277. {
  1278. struct channel_path *chp;
  1279. struct channel_path_desc *desc;
  1280. chp = css[0]->chps[sch->schib.pmcw.chpid[chp_no]];
  1281. if (!chp)
  1282. return NULL;
  1283. desc = kmalloc(sizeof(struct channel_path_desc), GFP_KERNEL);
  1284. if (!desc)
  1285. return NULL;
  1286. memcpy(desc, &chp->desc, sizeof(struct channel_path_desc));
  1287. return desc;
  1288. }
  1289. static int reset_channel_path(struct channel_path *chp)
  1290. {
  1291. int cc;
  1292. cc = rchp(chp->id);
  1293. switch (cc) {
  1294. case 0:
  1295. return 0;
  1296. case 2:
  1297. return -EBUSY;
  1298. default:
  1299. return -ENODEV;
  1300. }
  1301. }
  1302. static void reset_channel_paths_css(struct channel_subsystem *css)
  1303. {
  1304. int i;
  1305. for (i = 0; i <= __MAX_CHPID; i++) {
  1306. if (css->chps[i])
  1307. reset_channel_path(css->chps[i]);
  1308. }
  1309. }
  1310. void cio_reset_channel_paths(void)
  1311. {
  1312. int i;
  1313. for (i = 0; i <= __MAX_CSSID; i++) {
  1314. if (css[i] && css[i]->valid)
  1315. reset_channel_paths_css(css[i]);
  1316. }
  1317. }
  1318. static int __init
  1319. chsc_alloc_sei_area(void)
  1320. {
  1321. sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
  1322. if (!sei_page)
  1323. printk(KERN_WARNING"Can't allocate page for processing of " \
  1324. "chsc machine checks!\n");
  1325. return (sei_page ? 0 : -ENOMEM);
  1326. }
  1327. int __init
  1328. chsc_enable_facility(int operation_code)
  1329. {
  1330. int ret;
  1331. struct {
  1332. struct chsc_header request;
  1333. u8 reserved1:4;
  1334. u8 format:4;
  1335. u8 reserved2;
  1336. u16 operation_code;
  1337. u32 reserved3;
  1338. u32 reserved4;
  1339. u32 operation_data_area[252];
  1340. struct chsc_header response;
  1341. u32 reserved5:4;
  1342. u32 format2:4;
  1343. u32 reserved6:24;
  1344. } *sda_area;
  1345. sda_area = (void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
  1346. if (!sda_area)
  1347. return -ENOMEM;
  1348. sda_area->request.length = 0x0400;
  1349. sda_area->request.code = 0x0031;
  1350. sda_area->operation_code = operation_code;
  1351. ret = chsc(sda_area);
  1352. if (ret > 0) {
  1353. ret = (ret == 3) ? -ENODEV : -EBUSY;
  1354. goto out;
  1355. }
  1356. switch (sda_area->response.code) {
  1357. case 0x0001: /* everything ok */
  1358. ret = 0;
  1359. break;
  1360. case 0x0003: /* invalid request block */
  1361. case 0x0007:
  1362. ret = -EINVAL;
  1363. break;
  1364. case 0x0004: /* command not provided */
  1365. case 0x0101: /* facility not provided */
  1366. ret = -EOPNOTSUPP;
  1367. break;
  1368. default: /* something went wrong */
  1369. ret = -EIO;
  1370. }
  1371. out:
  1372. free_page((unsigned long)sda_area);
  1373. return ret;
  1374. }
  1375. subsys_initcall(chsc_alloc_sei_area);
  1376. struct css_general_char css_general_characteristics;
  1377. struct css_chsc_char css_chsc_characteristics;
  1378. int __init
  1379. chsc_determine_css_characteristics(void)
  1380. {
  1381. int result;
  1382. struct {
  1383. struct chsc_header request;
  1384. u32 reserved1;
  1385. u32 reserved2;
  1386. u32 reserved3;
  1387. struct chsc_header response;
  1388. u32 reserved4;
  1389. u32 general_char[510];
  1390. u32 chsc_char[518];
  1391. } *scsc_area;
  1392. scsc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
  1393. if (!scsc_area) {
  1394. printk(KERN_WARNING"cio: Was not able to determine available" \
  1395. "CHSCs due to no memory.\n");
  1396. return -ENOMEM;
  1397. }
  1398. scsc_area->request.length = 0x0010;
  1399. scsc_area->request.code = 0x0010;
  1400. result = chsc(scsc_area);
  1401. if (result) {
  1402. printk(KERN_WARNING"cio: Was not able to determine " \
  1403. "available CHSCs, cc=%i.\n", result);
  1404. result = -EIO;
  1405. goto exit;
  1406. }
  1407. if (scsc_area->response.code != 1) {
  1408. printk(KERN_WARNING"cio: Was not able to determine " \
  1409. "available CHSCs.\n");
  1410. result = -EIO;
  1411. goto exit;
  1412. }
  1413. memcpy(&css_general_characteristics, scsc_area->general_char,
  1414. sizeof(css_general_characteristics));
  1415. memcpy(&css_chsc_characteristics, scsc_area->chsc_char,
  1416. sizeof(css_chsc_characteristics));
  1417. exit:
  1418. free_page ((unsigned long) scsc_area);
  1419. return result;
  1420. }
  1421. EXPORT_SYMBOL_GPL(css_general_characteristics);
  1422. EXPORT_SYMBOL_GPL(css_chsc_characteristics);