tape_3590.c 45 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759
  1. /*
  2. * drivers/s390/char/tape_3590.c
  3. * tape device discipline for 3590 tapes.
  4. *
  5. * Copyright IBM Corp. 2001, 2009
  6. * Author(s): Stefan Bader <shbader@de.ibm.com>
  7. * Michael Holzheu <holzheu@de.ibm.com>
  8. * Martin Schwidefsky <schwidefsky@de.ibm.com>
  9. */
  10. #define KMSG_COMPONENT "tape"
  11. #include <linux/module.h>
  12. #include <linux/init.h>
  13. #include <linux/bio.h>
  14. #include <asm/ebcdic.h>
  15. #define TAPE_DBF_AREA tape_3590_dbf
  16. #define BUFSIZE 512 /* size of buffers for dynamic generated messages */
  17. #include "tape.h"
  18. #include "tape_std.h"
  19. #include "tape_3590.h"
  20. /*
  21. * Pointer to debug area.
  22. */
  23. debug_info_t *TAPE_DBF_AREA = NULL;
  24. EXPORT_SYMBOL(TAPE_DBF_AREA);
  25. /*******************************************************************
  26. * Error Recovery fuctions:
  27. * - Read Opposite: implemented
  28. * - Read Device (buffered) log: BRA
  29. * - Read Library log: BRA
  30. * - Swap Devices: BRA
  31. * - Long Busy: implemented
  32. * - Special Intercept: BRA
  33. * - Read Alternate: implemented
  34. *******************************************************************/
  35. #define KMSG_COMPONENT "tape"
  36. static const char *tape_3590_msg[TAPE_3590_MAX_MSG] = {
  37. [0x00] = "",
  38. [0x10] = "Lost Sense",
  39. [0x11] = "Assigned Elsewhere",
  40. [0x12] = "Allegiance Reset",
  41. [0x13] = "Shared Access Violation",
  42. [0x20] = "Command Reject",
  43. [0x21] = "Configuration Error",
  44. [0x22] = "Protection Exception",
  45. [0x23] = "Write Protect",
  46. [0x24] = "Write Length",
  47. [0x25] = "Read-Only Format",
  48. [0x31] = "Beginning of Partition",
  49. [0x33] = "End of Partition",
  50. [0x34] = "End of Data",
  51. [0x35] = "Block not found",
  52. [0x40] = "Device Intervention",
  53. [0x41] = "Loader Intervention",
  54. [0x42] = "Library Intervention",
  55. [0x50] = "Write Error",
  56. [0x51] = "Erase Error",
  57. [0x52] = "Formatting Error",
  58. [0x53] = "Read Error",
  59. [0x54] = "Unsupported Format",
  60. [0x55] = "No Formatting",
  61. [0x56] = "Positioning lost",
  62. [0x57] = "Read Length",
  63. [0x60] = "Unsupported Medium",
  64. [0x61] = "Medium Length Error",
  65. [0x62] = "Medium removed",
  66. [0x64] = "Load Check",
  67. [0x65] = "Unload Check",
  68. [0x70] = "Equipment Check",
  69. [0x71] = "Bus out Check",
  70. [0x72] = "Protocol Error",
  71. [0x73] = "Interface Error",
  72. [0x74] = "Overrun",
  73. [0x75] = "Halt Signal",
  74. [0x90] = "Device fenced",
  75. [0x91] = "Device Path fenced",
  76. [0xa0] = "Volume misplaced",
  77. [0xa1] = "Volume inaccessible",
  78. [0xa2] = "Volume in input",
  79. [0xa3] = "Volume ejected",
  80. [0xa4] = "All categories reserved",
  81. [0xa5] = "Duplicate Volume",
  82. [0xa6] = "Library Manager Offline",
  83. [0xa7] = "Library Output Station full",
  84. [0xa8] = "Vision System non-operational",
  85. [0xa9] = "Library Manager Equipment Check",
  86. [0xaa] = "Library Equipment Check",
  87. [0xab] = "All Library Cells full",
  88. [0xac] = "No Cleaner Volumes in Library",
  89. [0xad] = "I/O Station door open",
  90. [0xae] = "Subsystem environmental alert",
  91. };
  92. static int crypt_supported(struct tape_device *device)
  93. {
  94. return TAPE390_CRYPT_SUPPORTED(TAPE_3590_CRYPT_INFO(device));
  95. }
  96. static int crypt_enabled(struct tape_device *device)
  97. {
  98. return TAPE390_CRYPT_ON(TAPE_3590_CRYPT_INFO(device));
  99. }
  100. static void ext_to_int_kekl(struct tape390_kekl *in,
  101. struct tape3592_kekl *out)
  102. {
  103. int i;
  104. memset(out, 0, sizeof(*out));
  105. if (in->type == TAPE390_KEKL_TYPE_HASH)
  106. out->flags |= 0x40;
  107. if (in->type_on_tape == TAPE390_KEKL_TYPE_HASH)
  108. out->flags |= 0x80;
  109. strncpy(out->label, in->label, 64);
  110. for (i = strlen(in->label); i < sizeof(out->label); i++)
  111. out->label[i] = ' ';
  112. ASCEBC(out->label, sizeof(out->label));
  113. }
  114. static void int_to_ext_kekl(struct tape3592_kekl *in,
  115. struct tape390_kekl *out)
  116. {
  117. memset(out, 0, sizeof(*out));
  118. if(in->flags & 0x40)
  119. out->type = TAPE390_KEKL_TYPE_HASH;
  120. else
  121. out->type = TAPE390_KEKL_TYPE_LABEL;
  122. if(in->flags & 0x80)
  123. out->type_on_tape = TAPE390_KEKL_TYPE_HASH;
  124. else
  125. out->type_on_tape = TAPE390_KEKL_TYPE_LABEL;
  126. memcpy(out->label, in->label, sizeof(in->label));
  127. EBCASC(out->label, sizeof(in->label));
  128. strstrip(out->label);
  129. }
  130. static void int_to_ext_kekl_pair(struct tape3592_kekl_pair *in,
  131. struct tape390_kekl_pair *out)
  132. {
  133. if (in->count == 0) {
  134. out->kekl[0].type = TAPE390_KEKL_TYPE_NONE;
  135. out->kekl[0].type_on_tape = TAPE390_KEKL_TYPE_NONE;
  136. out->kekl[1].type = TAPE390_KEKL_TYPE_NONE;
  137. out->kekl[1].type_on_tape = TAPE390_KEKL_TYPE_NONE;
  138. } else if (in->count == 1) {
  139. int_to_ext_kekl(&in->kekl[0], &out->kekl[0]);
  140. out->kekl[1].type = TAPE390_KEKL_TYPE_NONE;
  141. out->kekl[1].type_on_tape = TAPE390_KEKL_TYPE_NONE;
  142. } else if (in->count == 2) {
  143. int_to_ext_kekl(&in->kekl[0], &out->kekl[0]);
  144. int_to_ext_kekl(&in->kekl[1], &out->kekl[1]);
  145. } else {
  146. printk("Invalid KEKL number: %d\n", in->count);
  147. BUG();
  148. }
  149. }
  150. static int check_ext_kekl(struct tape390_kekl *kekl)
  151. {
  152. if (kekl->type == TAPE390_KEKL_TYPE_NONE)
  153. goto invalid;
  154. if (kekl->type > TAPE390_KEKL_TYPE_HASH)
  155. goto invalid;
  156. if (kekl->type_on_tape == TAPE390_KEKL_TYPE_NONE)
  157. goto invalid;
  158. if (kekl->type_on_tape > TAPE390_KEKL_TYPE_HASH)
  159. goto invalid;
  160. if ((kekl->type == TAPE390_KEKL_TYPE_HASH) &&
  161. (kekl->type_on_tape == TAPE390_KEKL_TYPE_LABEL))
  162. goto invalid;
  163. return 0;
  164. invalid:
  165. return -EINVAL;
  166. }
  167. static int check_ext_kekl_pair(struct tape390_kekl_pair *kekls)
  168. {
  169. if (check_ext_kekl(&kekls->kekl[0]))
  170. goto invalid;
  171. if (check_ext_kekl(&kekls->kekl[1]))
  172. goto invalid;
  173. return 0;
  174. invalid:
  175. return -EINVAL;
  176. }
  177. /*
  178. * Query KEKLs
  179. */
  180. static int tape_3592_kekl_query(struct tape_device *device,
  181. struct tape390_kekl_pair *ext_kekls)
  182. {
  183. struct tape_request *request;
  184. struct tape3592_kekl_query_order *order;
  185. struct tape3592_kekl_query_data *int_kekls;
  186. int rc;
  187. DBF_EVENT(6, "tape3592_kekl_query\n");
  188. int_kekls = kmalloc(sizeof(*int_kekls), GFP_KERNEL|GFP_DMA);
  189. if (!int_kekls)
  190. return -ENOMEM;
  191. request = tape_alloc_request(2, sizeof(*order));
  192. if (IS_ERR(request)) {
  193. rc = PTR_ERR(request);
  194. goto fail_malloc;
  195. }
  196. order = request->cpdata;
  197. memset(order,0,sizeof(*order));
  198. order->code = 0xe2;
  199. order->max_count = 2;
  200. request->op = TO_KEKL_QUERY;
  201. tape_ccw_cc(request->cpaddr, PERF_SUBSYS_FUNC, sizeof(*order), order);
  202. tape_ccw_end(request->cpaddr + 1, READ_SS_DATA, sizeof(*int_kekls),
  203. int_kekls);
  204. rc = tape_do_io(device, request);
  205. if (rc)
  206. goto fail_request;
  207. int_to_ext_kekl_pair(&int_kekls->kekls, ext_kekls);
  208. rc = 0;
  209. fail_request:
  210. tape_free_request(request);
  211. fail_malloc:
  212. kfree(int_kekls);
  213. return rc;
  214. }
  215. /*
  216. * IOCTL: Query KEKLs
  217. */
  218. static int tape_3592_ioctl_kekl_query(struct tape_device *device,
  219. unsigned long arg)
  220. {
  221. int rc;
  222. struct tape390_kekl_pair *ext_kekls;
  223. DBF_EVENT(6, "tape_3592_ioctl_kekl_query\n");
  224. if (!crypt_supported(device))
  225. return -ENOSYS;
  226. if (!crypt_enabled(device))
  227. return -EUNATCH;
  228. ext_kekls = kmalloc(sizeof(*ext_kekls), GFP_KERNEL);
  229. if (!ext_kekls)
  230. return -ENOMEM;
  231. rc = tape_3592_kekl_query(device, ext_kekls);
  232. if (rc != 0)
  233. goto fail;
  234. if (copy_to_user((char __user *) arg, ext_kekls, sizeof(*ext_kekls))) {
  235. rc = -EFAULT;
  236. goto fail;
  237. }
  238. rc = 0;
  239. fail:
  240. kfree(ext_kekls);
  241. return rc;
  242. }
  243. static int tape_3590_mttell(struct tape_device *device, int mt_count);
  244. /*
  245. * Set KEKLs
  246. */
  247. static int tape_3592_kekl_set(struct tape_device *device,
  248. struct tape390_kekl_pair *ext_kekls)
  249. {
  250. struct tape_request *request;
  251. struct tape3592_kekl_set_order *order;
  252. DBF_EVENT(6, "tape3592_kekl_set\n");
  253. if (check_ext_kekl_pair(ext_kekls)) {
  254. DBF_EVENT(6, "invalid kekls\n");
  255. return -EINVAL;
  256. }
  257. if (tape_3590_mttell(device, 0) != 0)
  258. return -EBADSLT;
  259. request = tape_alloc_request(1, sizeof(*order));
  260. if (IS_ERR(request))
  261. return PTR_ERR(request);
  262. order = request->cpdata;
  263. memset(order, 0, sizeof(*order));
  264. order->code = 0xe3;
  265. order->kekls.count = 2;
  266. ext_to_int_kekl(&ext_kekls->kekl[0], &order->kekls.kekl[0]);
  267. ext_to_int_kekl(&ext_kekls->kekl[1], &order->kekls.kekl[1]);
  268. request->op = TO_KEKL_SET;
  269. tape_ccw_end(request->cpaddr, PERF_SUBSYS_FUNC, sizeof(*order), order);
  270. return tape_do_io_free(device, request);
  271. }
  272. /*
  273. * IOCTL: Set KEKLs
  274. */
  275. static int tape_3592_ioctl_kekl_set(struct tape_device *device,
  276. unsigned long arg)
  277. {
  278. int rc;
  279. struct tape390_kekl_pair *ext_kekls;
  280. DBF_EVENT(6, "tape_3592_ioctl_kekl_set\n");
  281. if (!crypt_supported(device))
  282. return -ENOSYS;
  283. if (!crypt_enabled(device))
  284. return -EUNATCH;
  285. ext_kekls = kmalloc(sizeof(*ext_kekls), GFP_KERNEL);
  286. if (!ext_kekls)
  287. return -ENOMEM;
  288. if (copy_from_user(ext_kekls, (char __user *)arg, sizeof(*ext_kekls))) {
  289. rc = -EFAULT;
  290. goto out;
  291. }
  292. rc = tape_3592_kekl_set(device, ext_kekls);
  293. out:
  294. kfree(ext_kekls);
  295. return rc;
  296. }
  297. /*
  298. * Enable encryption
  299. */
  300. static int tape_3592_enable_crypt(struct tape_device *device)
  301. {
  302. struct tape_request *request;
  303. char *data;
  304. DBF_EVENT(6, "tape_3592_enable_crypt\n");
  305. if (!crypt_supported(device))
  306. return -ENOSYS;
  307. request = tape_alloc_request(2, 72);
  308. if (IS_ERR(request))
  309. return PTR_ERR(request);
  310. data = request->cpdata;
  311. memset(data,0,72);
  312. data[0] = 0x05;
  313. data[36 + 0] = 0x03;
  314. data[36 + 1] = 0x03;
  315. data[36 + 4] = 0x40;
  316. data[36 + 6] = 0x01;
  317. data[36 + 14] = 0x2f;
  318. data[36 + 18] = 0xc3;
  319. data[36 + 35] = 0x72;
  320. request->op = TO_CRYPT_ON;
  321. tape_ccw_cc(request->cpaddr, MODE_SET_CB, 36, data);
  322. tape_ccw_end(request->cpaddr + 1, MODE_SET_CB, 36, data + 36);
  323. return tape_do_io_free(device, request);
  324. }
  325. /*
  326. * Disable encryption
  327. */
  328. static int tape_3592_disable_crypt(struct tape_device *device)
  329. {
  330. struct tape_request *request;
  331. char *data;
  332. DBF_EVENT(6, "tape_3592_disable_crypt\n");
  333. if (!crypt_supported(device))
  334. return -ENOSYS;
  335. request = tape_alloc_request(2, 72);
  336. if (IS_ERR(request))
  337. return PTR_ERR(request);
  338. data = request->cpdata;
  339. memset(data,0,72);
  340. data[0] = 0x05;
  341. data[36 + 0] = 0x03;
  342. data[36 + 1] = 0x03;
  343. data[36 + 35] = 0x32;
  344. request->op = TO_CRYPT_OFF;
  345. tape_ccw_cc(request->cpaddr, MODE_SET_CB, 36, data);
  346. tape_ccw_end(request->cpaddr + 1, MODE_SET_CB, 36, data + 36);
  347. return tape_do_io_free(device, request);
  348. }
  349. /*
  350. * IOCTL: Set encryption status
  351. */
  352. static int tape_3592_ioctl_crypt_set(struct tape_device *device,
  353. unsigned long arg)
  354. {
  355. struct tape390_crypt_info info;
  356. DBF_EVENT(6, "tape_3592_ioctl_crypt_set\n");
  357. if (!crypt_supported(device))
  358. return -ENOSYS;
  359. if (copy_from_user(&info, (char __user *)arg, sizeof(info)))
  360. return -EFAULT;
  361. if (info.status & ~TAPE390_CRYPT_ON_MASK)
  362. return -EINVAL;
  363. if (info.status & TAPE390_CRYPT_ON_MASK)
  364. return tape_3592_enable_crypt(device);
  365. else
  366. return tape_3592_disable_crypt(device);
  367. }
  368. static int tape_3590_sense_medium(struct tape_device *device);
  369. /*
  370. * IOCTL: Query enryption status
  371. */
  372. static int tape_3592_ioctl_crypt_query(struct tape_device *device,
  373. unsigned long arg)
  374. {
  375. DBF_EVENT(6, "tape_3592_ioctl_crypt_query\n");
  376. if (!crypt_supported(device))
  377. return -ENOSYS;
  378. tape_3590_sense_medium(device);
  379. if (copy_to_user((char __user *) arg, &TAPE_3590_CRYPT_INFO(device),
  380. sizeof(TAPE_3590_CRYPT_INFO(device))))
  381. return -EFAULT;
  382. else
  383. return 0;
  384. }
  385. /*
  386. * 3590 IOCTL Overload
  387. */
  388. static int
  389. tape_3590_ioctl(struct tape_device *device, unsigned int cmd, unsigned long arg)
  390. {
  391. switch (cmd) {
  392. case TAPE390_DISPLAY: {
  393. struct display_struct disp;
  394. if (copy_from_user(&disp, (char __user *) arg, sizeof(disp)))
  395. return -EFAULT;
  396. return tape_std_display(device, &disp);
  397. }
  398. case TAPE390_KEKL_SET:
  399. return tape_3592_ioctl_kekl_set(device, arg);
  400. case TAPE390_KEKL_QUERY:
  401. return tape_3592_ioctl_kekl_query(device, arg);
  402. case TAPE390_CRYPT_SET:
  403. return tape_3592_ioctl_crypt_set(device, arg);
  404. case TAPE390_CRYPT_QUERY:
  405. return tape_3592_ioctl_crypt_query(device, arg);
  406. default:
  407. return -EINVAL; /* no additional ioctls */
  408. }
  409. }
  410. /*
  411. * SENSE Medium: Get Sense data about medium state
  412. */
  413. static int
  414. tape_3590_sense_medium(struct tape_device *device)
  415. {
  416. struct tape_request *request;
  417. request = tape_alloc_request(1, 128);
  418. if (IS_ERR(request))
  419. return PTR_ERR(request);
  420. request->op = TO_MSEN;
  421. tape_ccw_end(request->cpaddr, MEDIUM_SENSE, 128, request->cpdata);
  422. return tape_do_io_free(device, request);
  423. }
  424. /*
  425. * MTTELL: Tell block. Return the number of block relative to current file.
  426. */
  427. static int
  428. tape_3590_mttell(struct tape_device *device, int mt_count)
  429. {
  430. __u64 block_id;
  431. int rc;
  432. rc = tape_std_read_block_id(device, &block_id);
  433. if (rc)
  434. return rc;
  435. return block_id >> 32;
  436. }
  437. /*
  438. * MTSEEK: seek to the specified block.
  439. */
  440. static int
  441. tape_3590_mtseek(struct tape_device *device, int count)
  442. {
  443. struct tape_request *request;
  444. DBF_EVENT(6, "xsee id: %x\n", count);
  445. request = tape_alloc_request(3, 4);
  446. if (IS_ERR(request))
  447. return PTR_ERR(request);
  448. request->op = TO_LBL;
  449. tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
  450. *(__u32 *) request->cpdata = count;
  451. tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
  452. tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
  453. return tape_do_io_free(device, request);
  454. }
  455. /*
  456. * Read Opposite Error Recovery Function:
  457. * Used, when Read Forward does not work
  458. */
  459. static void
  460. tape_3590_read_opposite(struct tape_device *device,
  461. struct tape_request *request)
  462. {
  463. struct tape_3590_disc_data *data;
  464. /*
  465. * We have allocated 4 ccws in tape_std_read, so we can now
  466. * transform the request to a read backward, followed by a
  467. * forward space block.
  468. */
  469. request->op = TO_RBA;
  470. tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
  471. data = device->discdata;
  472. tape_ccw_cc_idal(request->cpaddr + 1, data->read_back_op,
  473. device->char_data.idal_buf);
  474. tape_ccw_cc(request->cpaddr + 2, FORSPACEBLOCK, 0, NULL);
  475. tape_ccw_end(request->cpaddr + 3, NOP, 0, NULL);
  476. DBF_EVENT(6, "xrop ccwg\n");
  477. }
  478. /*
  479. * Read Attention Msg
  480. * This should be done after an interrupt with attention bit (0x80)
  481. * in device state.
  482. *
  483. * After a "read attention message" request there are two possible
  484. * results:
  485. *
  486. * 1. A unit check is presented, when attention sense is present (e.g. when
  487. * a medium has been unloaded). The attention sense comes then
  488. * together with the unit check. The recovery action is either "retry"
  489. * (in case there is an attention message pending) or "permanent error".
  490. *
  491. * 2. The attention msg is written to the "read subsystem data" buffer.
  492. * In this case we probably should print it to the console.
  493. */
  494. static int
  495. tape_3590_read_attmsg(struct tape_device *device)
  496. {
  497. struct tape_request *request;
  498. char *buf;
  499. request = tape_alloc_request(3, 4096);
  500. if (IS_ERR(request))
  501. return PTR_ERR(request);
  502. request->op = TO_READ_ATTMSG;
  503. buf = request->cpdata;
  504. buf[0] = PREP_RD_SS_DATA;
  505. buf[6] = RD_ATTMSG; /* read att msg */
  506. tape_ccw_cc(request->cpaddr, PERFORM_SS_FUNC, 12, buf);
  507. tape_ccw_cc(request->cpaddr + 1, READ_SS_DATA, 4096 - 12, buf + 12);
  508. tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
  509. return tape_do_io_free(device, request);
  510. }
  511. /*
  512. * These functions are used to schedule follow-up actions from within an
  513. * interrupt context (like unsolicited interrupts).
  514. */
  515. struct work_handler_data {
  516. struct tape_device *device;
  517. enum tape_op op;
  518. struct work_struct work;
  519. };
  520. static void
  521. tape_3590_work_handler(struct work_struct *work)
  522. {
  523. struct work_handler_data *p =
  524. container_of(work, struct work_handler_data, work);
  525. switch (p->op) {
  526. case TO_MSEN:
  527. tape_3590_sense_medium(p->device);
  528. break;
  529. case TO_READ_ATTMSG:
  530. tape_3590_read_attmsg(p->device);
  531. break;
  532. case TO_CRYPT_ON:
  533. tape_3592_enable_crypt(p->device);
  534. break;
  535. case TO_CRYPT_OFF:
  536. tape_3592_disable_crypt(p->device);
  537. break;
  538. default:
  539. DBF_EVENT(3, "T3590: work handler undefined for "
  540. "operation 0x%02x\n", p->op);
  541. }
  542. tape_put_device(p->device);
  543. kfree(p);
  544. }
  545. static int
  546. tape_3590_schedule_work(struct tape_device *device, enum tape_op op)
  547. {
  548. struct work_handler_data *p;
  549. if ((p = kzalloc(sizeof(*p), GFP_ATOMIC)) == NULL)
  550. return -ENOMEM;
  551. INIT_WORK(&p->work, tape_3590_work_handler);
  552. p->device = tape_get_device_reference(device);
  553. p->op = op;
  554. schedule_work(&p->work);
  555. return 0;
  556. }
  557. #ifdef CONFIG_S390_TAPE_BLOCK
  558. /*
  559. * Tape Block READ
  560. */
  561. static struct tape_request *
  562. tape_3590_bread(struct tape_device *device, struct request *req)
  563. {
  564. struct tape_request *request;
  565. struct ccw1 *ccw;
  566. int count = 0, start_block;
  567. unsigned off;
  568. char *dst;
  569. struct bio_vec *bv;
  570. struct req_iterator iter;
  571. DBF_EVENT(6, "xBREDid:");
  572. start_block = blk_rq_pos(req) >> TAPEBLOCK_HSEC_S2B;
  573. DBF_EVENT(6, "start_block = %i\n", start_block);
  574. rq_for_each_segment(bv, req, iter)
  575. count += bv->bv_len >> (TAPEBLOCK_HSEC_S2B + 9);
  576. request = tape_alloc_request(2 + count + 1, 4);
  577. if (IS_ERR(request))
  578. return request;
  579. request->op = TO_BLOCK;
  580. *(__u32 *) request->cpdata = start_block;
  581. ccw = request->cpaddr;
  582. ccw = tape_ccw_cc(ccw, MODE_SET_DB, 1, device->modeset_byte);
  583. /*
  584. * We always setup a nop after the mode set ccw. This slot is
  585. * used in tape_std_check_locate to insert a locate ccw if the
  586. * current tape position doesn't match the start block to be read.
  587. */
  588. ccw = tape_ccw_cc(ccw, NOP, 0, NULL);
  589. rq_for_each_segment(bv, req, iter) {
  590. dst = page_address(bv->bv_page) + bv->bv_offset;
  591. for (off = 0; off < bv->bv_len; off += TAPEBLOCK_HSEC_SIZE) {
  592. ccw->flags = CCW_FLAG_CC;
  593. ccw->cmd_code = READ_FORWARD;
  594. ccw->count = TAPEBLOCK_HSEC_SIZE;
  595. set_normalized_cda(ccw, (void *) __pa(dst));
  596. ccw++;
  597. dst += TAPEBLOCK_HSEC_SIZE;
  598. }
  599. BUG_ON(off > bv->bv_len);
  600. }
  601. ccw = tape_ccw_end(ccw, NOP, 0, NULL);
  602. DBF_EVENT(6, "xBREDccwg\n");
  603. return request;
  604. }
  605. static void
  606. tape_3590_free_bread(struct tape_request *request)
  607. {
  608. struct ccw1 *ccw;
  609. /* Last ccw is a nop and doesn't need clear_normalized_cda */
  610. for (ccw = request->cpaddr; ccw->flags & CCW_FLAG_CC; ccw++)
  611. if (ccw->cmd_code == READ_FORWARD)
  612. clear_normalized_cda(ccw);
  613. tape_free_request(request);
  614. }
  615. /*
  616. * check_locate is called just before the tape request is passed to
  617. * the common io layer for execution. It has to check the current
  618. * tape position and insert a locate ccw if it doesn't match the
  619. * start block for the request.
  620. */
  621. static void
  622. tape_3590_check_locate(struct tape_device *device, struct tape_request *request)
  623. {
  624. __u32 *start_block;
  625. start_block = (__u32 *) request->cpdata;
  626. if (*start_block != device->blk_data.block_position) {
  627. /* Add the start offset of the file to get the real block. */
  628. *start_block += device->bof;
  629. tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
  630. }
  631. }
  632. #endif
  633. static void tape_3590_med_state_set(struct tape_device *device,
  634. struct tape_3590_med_sense *sense)
  635. {
  636. struct tape390_crypt_info *c_info;
  637. c_info = &TAPE_3590_CRYPT_INFO(device);
  638. DBF_EVENT(6, "medium state: %x:%x\n", sense->macst, sense->masst);
  639. switch (sense->macst) {
  640. case 0x04:
  641. case 0x05:
  642. case 0x06:
  643. tape_med_state_set(device, MS_UNLOADED);
  644. TAPE_3590_CRYPT_INFO(device).medium_status = 0;
  645. return;
  646. case 0x08:
  647. case 0x09:
  648. tape_med_state_set(device, MS_LOADED);
  649. break;
  650. default:
  651. tape_med_state_set(device, MS_UNKNOWN);
  652. return;
  653. }
  654. c_info->medium_status |= TAPE390_MEDIUM_LOADED_MASK;
  655. if (sense->flags & MSENSE_CRYPT_MASK) {
  656. DBF_EVENT(6, "Medium is encrypted (%04x)\n", sense->flags);
  657. c_info->medium_status |= TAPE390_MEDIUM_ENCRYPTED_MASK;
  658. } else {
  659. DBF_EVENT(6, "Medium is not encrypted %04x\n", sense->flags);
  660. c_info->medium_status &= ~TAPE390_MEDIUM_ENCRYPTED_MASK;
  661. }
  662. }
  663. /*
  664. * The done handler is called at device/channel end and wakes up the sleeping
  665. * process
  666. */
  667. static int
  668. tape_3590_done(struct tape_device *device, struct tape_request *request)
  669. {
  670. struct tape_3590_disc_data *disc_data;
  671. DBF_EVENT(6, "%s done\n", tape_op_verbose[request->op]);
  672. disc_data = device->discdata;
  673. switch (request->op) {
  674. case TO_BSB:
  675. case TO_BSF:
  676. case TO_DSE:
  677. case TO_FSB:
  678. case TO_FSF:
  679. case TO_LBL:
  680. case TO_RFO:
  681. case TO_RBA:
  682. case TO_REW:
  683. case TO_WRI:
  684. case TO_WTM:
  685. case TO_BLOCK:
  686. case TO_LOAD:
  687. tape_med_state_set(device, MS_LOADED);
  688. break;
  689. case TO_RUN:
  690. tape_med_state_set(device, MS_UNLOADED);
  691. tape_3590_schedule_work(device, TO_CRYPT_OFF);
  692. break;
  693. case TO_MSEN:
  694. tape_3590_med_state_set(device, request->cpdata);
  695. break;
  696. case TO_CRYPT_ON:
  697. TAPE_3590_CRYPT_INFO(device).status
  698. |= TAPE390_CRYPT_ON_MASK;
  699. *(device->modeset_byte) |= 0x03;
  700. break;
  701. case TO_CRYPT_OFF:
  702. TAPE_3590_CRYPT_INFO(device).status
  703. &= ~TAPE390_CRYPT_ON_MASK;
  704. *(device->modeset_byte) &= ~0x03;
  705. break;
  706. case TO_RBI: /* RBI seems to succeed even without medium loaded. */
  707. case TO_NOP: /* Same to NOP. */
  708. case TO_READ_CONFIG:
  709. case TO_READ_ATTMSG:
  710. case TO_DIS:
  711. case TO_ASSIGN:
  712. case TO_UNASSIGN:
  713. case TO_SIZE:
  714. case TO_KEKL_SET:
  715. case TO_KEKL_QUERY:
  716. case TO_RDC:
  717. break;
  718. }
  719. return TAPE_IO_SUCCESS;
  720. }
  721. /*
  722. * This fuction is called, when error recovery was successfull
  723. */
  724. static inline int
  725. tape_3590_erp_succeded(struct tape_device *device, struct tape_request *request)
  726. {
  727. DBF_EVENT(3, "Error Recovery successful for %s\n",
  728. tape_op_verbose[request->op]);
  729. return tape_3590_done(device, request);
  730. }
  731. /*
  732. * This fuction is called, when error recovery was not successfull
  733. */
  734. static inline int
  735. tape_3590_erp_failed(struct tape_device *device, struct tape_request *request,
  736. struct irb *irb, int rc)
  737. {
  738. DBF_EVENT(3, "Error Recovery failed for %s\n",
  739. tape_op_verbose[request->op]);
  740. tape_dump_sense_dbf(device, request, irb);
  741. return rc;
  742. }
  743. /*
  744. * Error Recovery do retry
  745. */
  746. static inline int
  747. tape_3590_erp_retry(struct tape_device *device, struct tape_request *request,
  748. struct irb *irb)
  749. {
  750. DBF_EVENT(2, "Retry: %s\n", tape_op_verbose[request->op]);
  751. tape_dump_sense_dbf(device, request, irb);
  752. return TAPE_IO_RETRY;
  753. }
  754. /*
  755. * Handle unsolicited interrupts
  756. */
  757. static int
  758. tape_3590_unsolicited_irq(struct tape_device *device, struct irb *irb)
  759. {
  760. if (irb->scsw.cmd.dstat == DEV_STAT_CHN_END)
  761. /* Probably result of halt ssch */
  762. return TAPE_IO_PENDING;
  763. else if (irb->scsw.cmd.dstat == 0x85)
  764. /* Device Ready */
  765. DBF_EVENT(3, "unsol.irq! tape ready: %08x\n", device->cdev_id);
  766. else if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
  767. tape_3590_schedule_work(device, TO_READ_ATTMSG);
  768. } else {
  769. DBF_EVENT(3, "unsol.irq! dev end: %08x\n", device->cdev_id);
  770. tape_dump_sense_dbf(device, NULL, irb);
  771. }
  772. /* check medium state */
  773. tape_3590_schedule_work(device, TO_MSEN);
  774. return TAPE_IO_SUCCESS;
  775. }
  776. /*
  777. * Basic Recovery routine
  778. */
  779. static int
  780. tape_3590_erp_basic(struct tape_device *device, struct tape_request *request,
  781. struct irb *irb, int rc)
  782. {
  783. struct tape_3590_sense *sense;
  784. sense = (struct tape_3590_sense *) irb->ecw;
  785. switch (sense->bra) {
  786. case SENSE_BRA_PER:
  787. return tape_3590_erp_failed(device, request, irb, rc);
  788. case SENSE_BRA_CONT:
  789. return tape_3590_erp_succeded(device, request);
  790. case SENSE_BRA_RE:
  791. return tape_3590_erp_retry(device, request, irb);
  792. case SENSE_BRA_DRE:
  793. return tape_3590_erp_failed(device, request, irb, rc);
  794. default:
  795. BUG();
  796. return TAPE_IO_STOP;
  797. }
  798. }
  799. /*
  800. * RDL: Read Device (buffered) log
  801. */
  802. static int
  803. tape_3590_erp_read_buf_log(struct tape_device *device,
  804. struct tape_request *request, struct irb *irb)
  805. {
  806. /*
  807. * We just do the basic error recovery at the moment (retry).
  808. * Perhaps in the future, we read the log and dump it somewhere...
  809. */
  810. return tape_3590_erp_basic(device, request, irb, -EIO);
  811. }
  812. /*
  813. * SWAP: Swap Devices
  814. */
  815. static int
  816. tape_3590_erp_swap(struct tape_device *device, struct tape_request *request,
  817. struct irb *irb)
  818. {
  819. /*
  820. * This error recovery should swap the tapes
  821. * if the original has a problem. The operation
  822. * should proceed with the new tape... this
  823. * should probably be done in user space!
  824. */
  825. dev_warn (&device->cdev->dev, "The tape medium must be loaded into a "
  826. "different tape unit\n");
  827. return tape_3590_erp_basic(device, request, irb, -EIO);
  828. }
  829. /*
  830. * LBY: Long Busy
  831. */
  832. static int
  833. tape_3590_erp_long_busy(struct tape_device *device,
  834. struct tape_request *request, struct irb *irb)
  835. {
  836. DBF_EVENT(6, "Device is busy\n");
  837. return TAPE_IO_LONG_BUSY;
  838. }
  839. /*
  840. * SPI: Special Intercept
  841. */
  842. static int
  843. tape_3590_erp_special_interrupt(struct tape_device *device,
  844. struct tape_request *request, struct irb *irb)
  845. {
  846. return tape_3590_erp_basic(device, request, irb, -EIO);
  847. }
  848. /*
  849. * RDA: Read Alternate
  850. */
  851. static int
  852. tape_3590_erp_read_alternate(struct tape_device *device,
  853. struct tape_request *request, struct irb *irb)
  854. {
  855. struct tape_3590_disc_data *data;
  856. /*
  857. * The issued Read Backward or Read Previous command is not
  858. * supported by the device
  859. * The recovery action should be to issue another command:
  860. * Read Revious: if Read Backward is not supported
  861. * Read Backward: if Read Previous is not supported
  862. */
  863. data = device->discdata;
  864. if (data->read_back_op == READ_PREVIOUS) {
  865. DBF_EVENT(2, "(%08x): No support for READ_PREVIOUS command\n",
  866. device->cdev_id);
  867. data->read_back_op = READ_BACKWARD;
  868. } else {
  869. DBF_EVENT(2, "(%08x): No support for READ_BACKWARD command\n",
  870. device->cdev_id);
  871. data->read_back_op = READ_PREVIOUS;
  872. }
  873. tape_3590_read_opposite(device, request);
  874. return tape_3590_erp_retry(device, request, irb);
  875. }
  876. /*
  877. * Error Recovery read opposite
  878. */
  879. static int
  880. tape_3590_erp_read_opposite(struct tape_device *device,
  881. struct tape_request *request, struct irb *irb)
  882. {
  883. switch (request->op) {
  884. case TO_RFO:
  885. /*
  886. * We did read forward, but the data could not be read.
  887. * We will read backward and then skip forward again.
  888. */
  889. tape_3590_read_opposite(device, request);
  890. return tape_3590_erp_retry(device, request, irb);
  891. case TO_RBA:
  892. /* We tried to read forward and backward, but hat no success */
  893. return tape_3590_erp_failed(device, request, irb, -EIO);
  894. break;
  895. default:
  896. return tape_3590_erp_failed(device, request, irb, -EIO);
  897. }
  898. }
  899. /*
  900. * Print an MIM (Media Information Message) (message code f0)
  901. */
  902. static void
  903. tape_3590_print_mim_msg_f0(struct tape_device *device, struct irb *irb)
  904. {
  905. struct tape_3590_sense *sense;
  906. char *exception, *service;
  907. exception = kmalloc(BUFSIZE, GFP_ATOMIC);
  908. service = kmalloc(BUFSIZE, GFP_ATOMIC);
  909. if (!exception || !service)
  910. goto out_nomem;
  911. sense = (struct tape_3590_sense *) irb->ecw;
  912. /* Exception Message */
  913. switch (sense->fmt.f70.emc) {
  914. case 0x02:
  915. snprintf(exception, BUFSIZE, "Data degraded");
  916. break;
  917. case 0x03:
  918. snprintf(exception, BUFSIZE, "Data degraded in partion %i",
  919. sense->fmt.f70.mp);
  920. break;
  921. case 0x04:
  922. snprintf(exception, BUFSIZE, "Medium degraded");
  923. break;
  924. case 0x05:
  925. snprintf(exception, BUFSIZE, "Medium degraded in partition %i",
  926. sense->fmt.f70.mp);
  927. break;
  928. case 0x06:
  929. snprintf(exception, BUFSIZE, "Block 0 Error");
  930. break;
  931. case 0x07:
  932. snprintf(exception, BUFSIZE, "Medium Exception 0x%02x",
  933. sense->fmt.f70.md);
  934. break;
  935. default:
  936. snprintf(exception, BUFSIZE, "0x%02x",
  937. sense->fmt.f70.emc);
  938. break;
  939. }
  940. /* Service Message */
  941. switch (sense->fmt.f70.smc) {
  942. case 0x02:
  943. snprintf(service, BUFSIZE, "Reference Media maintenance "
  944. "procedure %i", sense->fmt.f70.md);
  945. break;
  946. default:
  947. snprintf(service, BUFSIZE, "0x%02x",
  948. sense->fmt.f70.smc);
  949. break;
  950. }
  951. dev_warn (&device->cdev->dev, "Tape media information: exception %s, "
  952. "service %s\n", exception, service);
  953. out_nomem:
  954. kfree(exception);
  955. kfree(service);
  956. }
  957. /*
  958. * Print an I/O Subsystem Service Information Message (message code f1)
  959. */
  960. static void
  961. tape_3590_print_io_sim_msg_f1(struct tape_device *device, struct irb *irb)
  962. {
  963. struct tape_3590_sense *sense;
  964. char *exception, *service;
  965. exception = kmalloc(BUFSIZE, GFP_ATOMIC);
  966. service = kmalloc(BUFSIZE, GFP_ATOMIC);
  967. if (!exception || !service)
  968. goto out_nomem;
  969. sense = (struct tape_3590_sense *) irb->ecw;
  970. /* Exception Message */
  971. switch (sense->fmt.f71.emc) {
  972. case 0x01:
  973. snprintf(exception, BUFSIZE, "Effect of failure is unknown");
  974. break;
  975. case 0x02:
  976. snprintf(exception, BUFSIZE, "CU Exception - no performance "
  977. "impact");
  978. break;
  979. case 0x03:
  980. snprintf(exception, BUFSIZE, "CU Exception on channel "
  981. "interface 0x%02x", sense->fmt.f71.md[0]);
  982. break;
  983. case 0x04:
  984. snprintf(exception, BUFSIZE, "CU Exception on device path "
  985. "0x%02x", sense->fmt.f71.md[0]);
  986. break;
  987. case 0x05:
  988. snprintf(exception, BUFSIZE, "CU Exception on library path "
  989. "0x%02x", sense->fmt.f71.md[0]);
  990. break;
  991. case 0x06:
  992. snprintf(exception, BUFSIZE, "CU Exception on node 0x%02x",
  993. sense->fmt.f71.md[0]);
  994. break;
  995. case 0x07:
  996. snprintf(exception, BUFSIZE, "CU Exception on partition "
  997. "0x%02x", sense->fmt.f71.md[0]);
  998. break;
  999. default:
  1000. snprintf(exception, BUFSIZE, "0x%02x",
  1001. sense->fmt.f71.emc);
  1002. }
  1003. /* Service Message */
  1004. switch (sense->fmt.f71.smc) {
  1005. case 0x01:
  1006. snprintf(service, BUFSIZE, "Repair impact is unknown");
  1007. break;
  1008. case 0x02:
  1009. snprintf(service, BUFSIZE, "Repair will not impact cu "
  1010. "performance");
  1011. break;
  1012. case 0x03:
  1013. if (sense->fmt.f71.mdf == 0)
  1014. snprintf(service, BUFSIZE, "Repair will disable node "
  1015. "0x%x on CU", sense->fmt.f71.md[1]);
  1016. else
  1017. snprintf(service, BUFSIZE, "Repair will disable "
  1018. "nodes (0x%x-0x%x) on CU", sense->fmt.f71.md[1],
  1019. sense->fmt.f71.md[2]);
  1020. break;
  1021. case 0x04:
  1022. if (sense->fmt.f71.mdf == 0)
  1023. snprintf(service, BUFSIZE, "Repair will disable "
  1024. "channel path 0x%x on CU",
  1025. sense->fmt.f71.md[1]);
  1026. else
  1027. snprintf(service, BUFSIZE, "Repair will disable cannel"
  1028. " paths (0x%x-0x%x) on CU",
  1029. sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
  1030. break;
  1031. case 0x05:
  1032. if (sense->fmt.f71.mdf == 0)
  1033. snprintf(service, BUFSIZE, "Repair will disable device"
  1034. " path 0x%x on CU", sense->fmt.f71.md[1]);
  1035. else
  1036. snprintf(service, BUFSIZE, "Repair will disable device"
  1037. " paths (0x%x-0x%x) on CU",
  1038. sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
  1039. break;
  1040. case 0x06:
  1041. if (sense->fmt.f71.mdf == 0)
  1042. snprintf(service, BUFSIZE, "Repair will disable "
  1043. "library path 0x%x on CU",
  1044. sense->fmt.f71.md[1]);
  1045. else
  1046. snprintf(service, BUFSIZE, "Repair will disable "
  1047. "library paths (0x%x-0x%x) on CU",
  1048. sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
  1049. break;
  1050. case 0x07:
  1051. snprintf(service, BUFSIZE, "Repair will disable access to CU");
  1052. break;
  1053. default:
  1054. snprintf(service, BUFSIZE, "0x%02x",
  1055. sense->fmt.f71.smc);
  1056. }
  1057. dev_warn (&device->cdev->dev, "I/O subsystem information: exception"
  1058. " %s, service %s\n", exception, service);
  1059. out_nomem:
  1060. kfree(exception);
  1061. kfree(service);
  1062. }
  1063. /*
  1064. * Print an Device Subsystem Service Information Message (message code f2)
  1065. */
  1066. static void
  1067. tape_3590_print_dev_sim_msg_f2(struct tape_device *device, struct irb *irb)
  1068. {
  1069. struct tape_3590_sense *sense;
  1070. char *exception, *service;
  1071. exception = kmalloc(BUFSIZE, GFP_ATOMIC);
  1072. service = kmalloc(BUFSIZE, GFP_ATOMIC);
  1073. if (!exception || !service)
  1074. goto out_nomem;
  1075. sense = (struct tape_3590_sense *) irb->ecw;
  1076. /* Exception Message */
  1077. switch (sense->fmt.f71.emc) {
  1078. case 0x01:
  1079. snprintf(exception, BUFSIZE, "Effect of failure is unknown");
  1080. break;
  1081. case 0x02:
  1082. snprintf(exception, BUFSIZE, "DV Exception - no performance"
  1083. " impact");
  1084. break;
  1085. case 0x03:
  1086. snprintf(exception, BUFSIZE, "DV Exception on channel "
  1087. "interface 0x%02x", sense->fmt.f71.md[0]);
  1088. break;
  1089. case 0x04:
  1090. snprintf(exception, BUFSIZE, "DV Exception on loader 0x%02x",
  1091. sense->fmt.f71.md[0]);
  1092. break;
  1093. case 0x05:
  1094. snprintf(exception, BUFSIZE, "DV Exception on message display"
  1095. " 0x%02x", sense->fmt.f71.md[0]);
  1096. break;
  1097. case 0x06:
  1098. snprintf(exception, BUFSIZE, "DV Exception in tape path");
  1099. break;
  1100. case 0x07:
  1101. snprintf(exception, BUFSIZE, "DV Exception in drive");
  1102. break;
  1103. default:
  1104. snprintf(exception, BUFSIZE, "0x%02x",
  1105. sense->fmt.f71.emc);
  1106. }
  1107. /* Service Message */
  1108. switch (sense->fmt.f71.smc) {
  1109. case 0x01:
  1110. snprintf(service, BUFSIZE, "Repair impact is unknown");
  1111. break;
  1112. case 0x02:
  1113. snprintf(service, BUFSIZE, "Repair will not impact device "
  1114. "performance");
  1115. break;
  1116. case 0x03:
  1117. if (sense->fmt.f71.mdf == 0)
  1118. snprintf(service, BUFSIZE, "Repair will disable "
  1119. "channel path 0x%x on DV",
  1120. sense->fmt.f71.md[1]);
  1121. else
  1122. snprintf(service, BUFSIZE, "Repair will disable "
  1123. "channel path (0x%x-0x%x) on DV",
  1124. sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
  1125. break;
  1126. case 0x04:
  1127. if (sense->fmt.f71.mdf == 0)
  1128. snprintf(service, BUFSIZE, "Repair will disable "
  1129. "interface 0x%x on DV", sense->fmt.f71.md[1]);
  1130. else
  1131. snprintf(service, BUFSIZE, "Repair will disable "
  1132. "interfaces (0x%x-0x%x) on DV",
  1133. sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
  1134. break;
  1135. case 0x05:
  1136. if (sense->fmt.f71.mdf == 0)
  1137. snprintf(service, BUFSIZE, "Repair will disable loader"
  1138. " 0x%x on DV", sense->fmt.f71.md[1]);
  1139. else
  1140. snprintf(service, BUFSIZE, "Repair will disable loader"
  1141. " (0x%x-0x%x) on DV",
  1142. sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
  1143. break;
  1144. case 0x07:
  1145. snprintf(service, BUFSIZE, "Repair will disable access to DV");
  1146. break;
  1147. case 0x08:
  1148. if (sense->fmt.f71.mdf == 0)
  1149. snprintf(service, BUFSIZE, "Repair will disable "
  1150. "message display 0x%x on DV",
  1151. sense->fmt.f71.md[1]);
  1152. else
  1153. snprintf(service, BUFSIZE, "Repair will disable "
  1154. "message displays (0x%x-0x%x) on DV",
  1155. sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
  1156. break;
  1157. case 0x09:
  1158. snprintf(service, BUFSIZE, "Clean DV");
  1159. break;
  1160. default:
  1161. snprintf(service, BUFSIZE, "0x%02x",
  1162. sense->fmt.f71.smc);
  1163. }
  1164. dev_warn (&device->cdev->dev, "Device subsystem information: exception"
  1165. " %s, service %s\n", exception, service);
  1166. out_nomem:
  1167. kfree(exception);
  1168. kfree(service);
  1169. }
  1170. /*
  1171. * Print standard ERA Message
  1172. */
  1173. static void
  1174. tape_3590_print_era_msg(struct tape_device *device, struct irb *irb)
  1175. {
  1176. struct tape_3590_sense *sense;
  1177. sense = (struct tape_3590_sense *) irb->ecw;
  1178. if (sense->mc == 0)
  1179. return;
  1180. if ((sense->mc > 0) && (sense->mc < TAPE_3590_MAX_MSG)) {
  1181. if (tape_3590_msg[sense->mc] != NULL)
  1182. dev_warn (&device->cdev->dev, "The tape unit has "
  1183. "issued sense message %s\n",
  1184. tape_3590_msg[sense->mc]);
  1185. else
  1186. dev_warn (&device->cdev->dev, "The tape unit has "
  1187. "issued an unknown sense message code 0x%x\n",
  1188. sense->mc);
  1189. return;
  1190. }
  1191. if (sense->mc == 0xf0) {
  1192. /* Standard Media Information Message */
  1193. dev_warn (&device->cdev->dev, "MIM SEV=%i, MC=%02x, ES=%x/%x, "
  1194. "RC=%02x-%04x-%02x\n", sense->fmt.f70.sev, sense->mc,
  1195. sense->fmt.f70.emc, sense->fmt.f70.smc,
  1196. sense->fmt.f70.refcode, sense->fmt.f70.mid,
  1197. sense->fmt.f70.fid);
  1198. tape_3590_print_mim_msg_f0(device, irb);
  1199. return;
  1200. }
  1201. if (sense->mc == 0xf1) {
  1202. /* Standard I/O Subsystem Service Information Message */
  1203. dev_warn (&device->cdev->dev, "IOSIM SEV=%i, DEVTYPE=3590/%02x,"
  1204. " MC=%02x, ES=%x/%x, REF=0x%04x-0x%04x-0x%04x\n",
  1205. sense->fmt.f71.sev, device->cdev->id.dev_model,
  1206. sense->mc, sense->fmt.f71.emc, sense->fmt.f71.smc,
  1207. sense->fmt.f71.refcode1, sense->fmt.f71.refcode2,
  1208. sense->fmt.f71.refcode3);
  1209. tape_3590_print_io_sim_msg_f1(device, irb);
  1210. return;
  1211. }
  1212. if (sense->mc == 0xf2) {
  1213. /* Standard Device Service Information Message */
  1214. dev_warn (&device->cdev->dev, "DEVSIM SEV=%i, DEVTYPE=3590/%02x"
  1215. ", MC=%02x, ES=%x/%x, REF=0x%04x-0x%04x-0x%04x\n",
  1216. sense->fmt.f71.sev, device->cdev->id.dev_model,
  1217. sense->mc, sense->fmt.f71.emc, sense->fmt.f71.smc,
  1218. sense->fmt.f71.refcode1, sense->fmt.f71.refcode2,
  1219. sense->fmt.f71.refcode3);
  1220. tape_3590_print_dev_sim_msg_f2(device, irb);
  1221. return;
  1222. }
  1223. if (sense->mc == 0xf3) {
  1224. /* Standard Library Service Information Message */
  1225. return;
  1226. }
  1227. dev_warn (&device->cdev->dev, "The tape unit has issued an unknown "
  1228. "sense message code %x\n", sense->mc);
  1229. }
  1230. static int tape_3590_crypt_error(struct tape_device *device,
  1231. struct tape_request *request, struct irb *irb)
  1232. {
  1233. u8 cu_rc, ekm_rc1;
  1234. u16 ekm_rc2;
  1235. u32 drv_rc;
  1236. const char *bus_id;
  1237. char *sense;
  1238. sense = ((struct tape_3590_sense *) irb->ecw)->fmt.data;
  1239. bus_id = dev_name(&device->cdev->dev);
  1240. cu_rc = sense[0];
  1241. drv_rc = *((u32*) &sense[5]) & 0xffffff;
  1242. ekm_rc1 = sense[9];
  1243. ekm_rc2 = *((u16*) &sense[10]);
  1244. if ((cu_rc == 0) && (ekm_rc2 == 0xee31))
  1245. /* key not defined on EKM */
  1246. return tape_3590_erp_basic(device, request, irb, -EKEYREJECTED);
  1247. if ((cu_rc == 1) || (cu_rc == 2))
  1248. /* No connection to EKM */
  1249. return tape_3590_erp_basic(device, request, irb, -ENOTCONN);
  1250. dev_err (&device->cdev->dev, "The tape unit failed to obtain the "
  1251. "encryption key from EKM\n");
  1252. return tape_3590_erp_basic(device, request, irb, -ENOKEY);
  1253. }
  1254. /*
  1255. * 3590 error Recovery routine:
  1256. * If possible, it tries to recover from the error. If this is not possible,
  1257. * inform the user about the problem.
  1258. */
  1259. static int
  1260. tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
  1261. struct irb *irb)
  1262. {
  1263. struct tape_3590_sense *sense;
  1264. int rc;
  1265. #ifdef CONFIG_S390_TAPE_BLOCK
  1266. if (request->op == TO_BLOCK) {
  1267. /*
  1268. * Recovery for block device requests. Set the block_position
  1269. * to something invalid and retry.
  1270. */
  1271. device->blk_data.block_position = -1;
  1272. if (request->retries-- <= 0)
  1273. return tape_3590_erp_failed(device, request, irb, -EIO);
  1274. else
  1275. return tape_3590_erp_retry(device, request, irb);
  1276. }
  1277. #endif
  1278. sense = (struct tape_3590_sense *) irb->ecw;
  1279. DBF_EVENT(6, "Unit Check: RQC = %x\n", sense->rc_rqc);
  1280. /*
  1281. * First check all RC-QRCs where we want to do something special
  1282. * - "break": basic error recovery is done
  1283. * - "goto out:": just print error message if available
  1284. */
  1285. rc = -EIO;
  1286. switch (sense->rc_rqc) {
  1287. case 0x1110:
  1288. tape_3590_print_era_msg(device, irb);
  1289. return tape_3590_erp_read_buf_log(device, request, irb);
  1290. case 0x2011:
  1291. tape_3590_print_era_msg(device, irb);
  1292. return tape_3590_erp_read_alternate(device, request, irb);
  1293. case 0x2230:
  1294. case 0x2231:
  1295. tape_3590_print_era_msg(device, irb);
  1296. return tape_3590_erp_special_interrupt(device, request, irb);
  1297. case 0x2240:
  1298. return tape_3590_crypt_error(device, request, irb);
  1299. case 0x3010:
  1300. DBF_EVENT(2, "(%08x): Backward at Beginning of Partition\n",
  1301. device->cdev_id);
  1302. return tape_3590_erp_basic(device, request, irb, -ENOSPC);
  1303. case 0x3012:
  1304. DBF_EVENT(2, "(%08x): Forward at End of Partition\n",
  1305. device->cdev_id);
  1306. return tape_3590_erp_basic(device, request, irb, -ENOSPC);
  1307. case 0x3020:
  1308. DBF_EVENT(2, "(%08x): End of Data Mark\n", device->cdev_id);
  1309. return tape_3590_erp_basic(device, request, irb, -ENOSPC);
  1310. case 0x3122:
  1311. DBF_EVENT(2, "(%08x): Rewind Unload initiated\n",
  1312. device->cdev_id);
  1313. return tape_3590_erp_basic(device, request, irb, -EIO);
  1314. case 0x3123:
  1315. DBF_EVENT(2, "(%08x): Rewind Unload complete\n",
  1316. device->cdev_id);
  1317. tape_med_state_set(device, MS_UNLOADED);
  1318. tape_3590_schedule_work(device, TO_CRYPT_OFF);
  1319. return tape_3590_erp_basic(device, request, irb, 0);
  1320. case 0x4010:
  1321. /*
  1322. * print additional msg since default msg
  1323. * "device intervention" is not very meaningfull
  1324. */
  1325. tape_med_state_set(device, MS_UNLOADED);
  1326. tape_3590_schedule_work(device, TO_CRYPT_OFF);
  1327. return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
  1328. case 0x4012: /* Device Long Busy */
  1329. /* XXX: Also use long busy handling here? */
  1330. DBF_EVENT(6, "(%08x): LONG BUSY\n", device->cdev_id);
  1331. tape_3590_print_era_msg(device, irb);
  1332. return tape_3590_erp_basic(device, request, irb, -EBUSY);
  1333. case 0x4014:
  1334. DBF_EVENT(6, "(%08x): Crypto LONG BUSY\n", device->cdev_id);
  1335. return tape_3590_erp_long_busy(device, request, irb);
  1336. case 0x5010:
  1337. if (sense->rac == 0xd0) {
  1338. /* Swap */
  1339. tape_3590_print_era_msg(device, irb);
  1340. return tape_3590_erp_swap(device, request, irb);
  1341. }
  1342. if (sense->rac == 0x26) {
  1343. /* Read Opposite */
  1344. tape_3590_print_era_msg(device, irb);
  1345. return tape_3590_erp_read_opposite(device, request,
  1346. irb);
  1347. }
  1348. return tape_3590_erp_basic(device, request, irb, -EIO);
  1349. case 0x5020:
  1350. case 0x5021:
  1351. case 0x5022:
  1352. case 0x5040:
  1353. case 0x5041:
  1354. case 0x5042:
  1355. tape_3590_print_era_msg(device, irb);
  1356. return tape_3590_erp_swap(device, request, irb);
  1357. case 0x5110:
  1358. case 0x5111:
  1359. return tape_3590_erp_basic(device, request, irb, -EMEDIUMTYPE);
  1360. case 0x5120:
  1361. case 0x1120:
  1362. tape_med_state_set(device, MS_UNLOADED);
  1363. tape_3590_schedule_work(device, TO_CRYPT_OFF);
  1364. return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
  1365. case 0x6020:
  1366. return tape_3590_erp_basic(device, request, irb, -EMEDIUMTYPE);
  1367. case 0x8011:
  1368. return tape_3590_erp_basic(device, request, irb, -EPERM);
  1369. case 0x8013:
  1370. dev_warn (&device->cdev->dev, "A different host has privileged"
  1371. " access to the tape unit\n");
  1372. return tape_3590_erp_basic(device, request, irb, -EPERM);
  1373. default:
  1374. return tape_3590_erp_basic(device, request, irb, -EIO);
  1375. }
  1376. }
  1377. /*
  1378. * 3590 interrupt handler:
  1379. */
  1380. static int
  1381. tape_3590_irq(struct tape_device *device, struct tape_request *request,
  1382. struct irb *irb)
  1383. {
  1384. if (request == NULL)
  1385. return tape_3590_unsolicited_irq(device, irb);
  1386. if ((irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) &&
  1387. (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) &&
  1388. (request->op == TO_WRI)) {
  1389. /* Write at end of volume */
  1390. DBF_EVENT(2, "End of volume\n");
  1391. return tape_3590_erp_failed(device, request, irb, -ENOSPC);
  1392. }
  1393. if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)
  1394. return tape_3590_unit_check(device, request, irb);
  1395. if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) {
  1396. if (irb->scsw.cmd.dstat == DEV_STAT_UNIT_EXCEP) {
  1397. if (request->op == TO_FSB || request->op == TO_BSB)
  1398. request->rescnt++;
  1399. else
  1400. DBF_EVENT(5, "Unit Exception!\n");
  1401. }
  1402. return tape_3590_done(device, request);
  1403. }
  1404. if (irb->scsw.cmd.dstat & DEV_STAT_CHN_END) {
  1405. DBF_EVENT(2, "cannel end\n");
  1406. return TAPE_IO_PENDING;
  1407. }
  1408. if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
  1409. DBF_EVENT(2, "Unit Attention when busy..\n");
  1410. return TAPE_IO_PENDING;
  1411. }
  1412. DBF_EVENT(6, "xunknownirq\n");
  1413. tape_dump_sense_dbf(device, request, irb);
  1414. return TAPE_IO_STOP;
  1415. }
  1416. static int tape_3590_read_dev_chars(struct tape_device *device,
  1417. struct tape_3590_rdc_data *rdc_data)
  1418. {
  1419. int rc;
  1420. struct tape_request *request;
  1421. request = tape_alloc_request(1, sizeof(*rdc_data));
  1422. if (IS_ERR(request))
  1423. return PTR_ERR(request);
  1424. request->op = TO_RDC;
  1425. tape_ccw_end(request->cpaddr, CCW_CMD_RDC, sizeof(*rdc_data),
  1426. request->cpdata);
  1427. rc = tape_do_io(device, request);
  1428. if (rc == 0)
  1429. memcpy(rdc_data, request->cpdata, sizeof(*rdc_data));
  1430. tape_free_request(request);
  1431. return rc;
  1432. }
  1433. /*
  1434. * Setup device function
  1435. */
  1436. static int
  1437. tape_3590_setup_device(struct tape_device *device)
  1438. {
  1439. int rc;
  1440. struct tape_3590_disc_data *data;
  1441. struct tape_3590_rdc_data *rdc_data;
  1442. DBF_EVENT(6, "3590 device setup\n");
  1443. data = kzalloc(sizeof(struct tape_3590_disc_data), GFP_KERNEL | GFP_DMA);
  1444. if (data == NULL)
  1445. return -ENOMEM;
  1446. data->read_back_op = READ_PREVIOUS;
  1447. device->discdata = data;
  1448. rdc_data = kmalloc(sizeof(*rdc_data), GFP_KERNEL | GFP_DMA);
  1449. if (!rdc_data) {
  1450. rc = -ENOMEM;
  1451. goto fail_kmalloc;
  1452. }
  1453. rc = tape_3590_read_dev_chars(device, rdc_data);
  1454. if (rc) {
  1455. DBF_LH(3, "Read device characteristics failed!\n");
  1456. goto fail_rdc_data;
  1457. }
  1458. rc = tape_std_assign(device);
  1459. if (rc)
  1460. goto fail_rdc_data;
  1461. if (rdc_data->data[31] == 0x13) {
  1462. data->crypt_info.capability |= TAPE390_CRYPT_SUPPORTED_MASK;
  1463. tape_3592_disable_crypt(device);
  1464. } else {
  1465. DBF_EVENT(6, "Device has NO crypto support\n");
  1466. }
  1467. /* Try to find out if medium is loaded */
  1468. rc = tape_3590_sense_medium(device);
  1469. if (rc) {
  1470. DBF_LH(3, "3590 medium sense returned %d\n", rc);
  1471. goto fail_rdc_data;
  1472. }
  1473. return 0;
  1474. fail_rdc_data:
  1475. kfree(rdc_data);
  1476. fail_kmalloc:
  1477. kfree(data);
  1478. return rc;
  1479. }
  1480. /*
  1481. * Cleanup device function
  1482. */
  1483. static void
  1484. tape_3590_cleanup_device(struct tape_device *device)
  1485. {
  1486. flush_scheduled_work();
  1487. tape_std_unassign(device);
  1488. kfree(device->discdata);
  1489. device->discdata = NULL;
  1490. }
  1491. /*
  1492. * List of 3590 magnetic tape commands.
  1493. */
  1494. static tape_mtop_fn tape_3590_mtop[TAPE_NR_MTOPS] = {
  1495. [MTRESET] = tape_std_mtreset,
  1496. [MTFSF] = tape_std_mtfsf,
  1497. [MTBSF] = tape_std_mtbsf,
  1498. [MTFSR] = tape_std_mtfsr,
  1499. [MTBSR] = tape_std_mtbsr,
  1500. [MTWEOF] = tape_std_mtweof,
  1501. [MTREW] = tape_std_mtrew,
  1502. [MTOFFL] = tape_std_mtoffl,
  1503. [MTNOP] = tape_std_mtnop,
  1504. [MTRETEN] = tape_std_mtreten,
  1505. [MTBSFM] = tape_std_mtbsfm,
  1506. [MTFSFM] = tape_std_mtfsfm,
  1507. [MTEOM] = tape_std_mteom,
  1508. [MTERASE] = tape_std_mterase,
  1509. [MTRAS1] = NULL,
  1510. [MTRAS2] = NULL,
  1511. [MTRAS3] = NULL,
  1512. [MTSETBLK] = tape_std_mtsetblk,
  1513. [MTSETDENSITY] = NULL,
  1514. [MTSEEK] = tape_3590_mtseek,
  1515. [MTTELL] = tape_3590_mttell,
  1516. [MTSETDRVBUFFER] = NULL,
  1517. [MTFSS] = NULL,
  1518. [MTBSS] = NULL,
  1519. [MTWSM] = NULL,
  1520. [MTLOCK] = NULL,
  1521. [MTUNLOCK] = NULL,
  1522. [MTLOAD] = tape_std_mtload,
  1523. [MTUNLOAD] = tape_std_mtunload,
  1524. [MTCOMPRESSION] = tape_std_mtcompression,
  1525. [MTSETPART] = NULL,
  1526. [MTMKPART] = NULL
  1527. };
  1528. /*
  1529. * Tape discipline structure for 3590.
  1530. */
  1531. static struct tape_discipline tape_discipline_3590 = {
  1532. .owner = THIS_MODULE,
  1533. .setup_device = tape_3590_setup_device,
  1534. .cleanup_device = tape_3590_cleanup_device,
  1535. .process_eov = tape_std_process_eov,
  1536. .irq = tape_3590_irq,
  1537. .read_block = tape_std_read_block,
  1538. .write_block = tape_std_write_block,
  1539. #ifdef CONFIG_S390_TAPE_BLOCK
  1540. .bread = tape_3590_bread,
  1541. .free_bread = tape_3590_free_bread,
  1542. .check_locate = tape_3590_check_locate,
  1543. #endif
  1544. .ioctl_fn = tape_3590_ioctl,
  1545. .mtop_array = tape_3590_mtop
  1546. };
  1547. static struct ccw_device_id tape_3590_ids[] = {
  1548. {CCW_DEVICE_DEVTYPE(0x3590, 0, 0x3590, 0), .driver_info = tape_3590},
  1549. {CCW_DEVICE_DEVTYPE(0x3592, 0, 0x3592, 0), .driver_info = tape_3592},
  1550. { /* end of list */ }
  1551. };
  1552. static int
  1553. tape_3590_online(struct ccw_device *cdev)
  1554. {
  1555. return tape_generic_online(dev_get_drvdata(&cdev->dev),
  1556. &tape_discipline_3590);
  1557. }
  1558. static struct ccw_driver tape_3590_driver = {
  1559. .name = "tape_3590",
  1560. .owner = THIS_MODULE,
  1561. .ids = tape_3590_ids,
  1562. .probe = tape_generic_probe,
  1563. .remove = tape_generic_remove,
  1564. .set_offline = tape_generic_offline,
  1565. .set_online = tape_3590_online,
  1566. .freeze = tape_generic_pm_suspend,
  1567. };
  1568. /*
  1569. * Setup discipline structure.
  1570. */
  1571. static int
  1572. tape_3590_init(void)
  1573. {
  1574. int rc;
  1575. TAPE_DBF_AREA = debug_register("tape_3590", 2, 2, 4 * sizeof(long));
  1576. debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
  1577. #ifdef DBF_LIKE_HELL
  1578. debug_set_level(TAPE_DBF_AREA, 6);
  1579. #endif
  1580. DBF_EVENT(3, "3590 init\n");
  1581. /* Register driver for 3590 tapes. */
  1582. rc = ccw_driver_register(&tape_3590_driver);
  1583. if (rc)
  1584. DBF_EVENT(3, "3590 init failed\n");
  1585. else
  1586. DBF_EVENT(3, "3590 registered\n");
  1587. return rc;
  1588. }
  1589. static void
  1590. tape_3590_exit(void)
  1591. {
  1592. ccw_driver_unregister(&tape_3590_driver);
  1593. debug_unregister(TAPE_DBF_AREA);
  1594. }
  1595. MODULE_DEVICE_TABLE(ccw, tape_3590_ids);
  1596. MODULE_AUTHOR("(C) 2001,2006 IBM Corporation");
  1597. MODULE_DESCRIPTION("Linux on zSeries channel attached 3590 tape device driver");
  1598. MODULE_LICENSE("GPL");
  1599. module_init(tape_3590_init);
  1600. module_exit(tape_3590_exit);