开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
dasd_diag.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：15k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

dasd_diag.c：源码内容
  1. /* 
  2.  * File...........: linux/drivers/s390/block/dasd_diag.c
  3.  * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
  4.  * Based on.......: linux/drivers/s390/block/mdisk.c
  5.  * ...............: by Hartmunt Penner <hpenner@de.ibm.com>
  6.  * Bugreports.to..: <Linux390@de.ibm.com>
  7.  * (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 1999,2000
  9.  * History of changes
  10.  * 07/13/00 Added fixup sections for diagnoses ans saved some registers
  11.  * 07/14/00 fixed constraints in newly generated inline asm
  12.  * 10/05/00 adapted to 'new' DASD driver
  13.  *          fixed return codes of dia250()
  14.  *          fixed partition handling and HDIO_GETGEO
  15.  */
  17. #include <linux/config.h>
  18. #include <linux/stddef.h>
  19. #include <linux/kernel.h>
  20. #include <asm/debug.h>
  22. #include <linux/slab.h>
  23. #include <linux/hdreg.h> /* HDIO_GETGEO                      */
  24. #include <linux/blk.h>
  25. #include <asm/ccwcache.h>
  26. #include <asm/dasd.h>
  28. #include <asm/ebcdic.h>
  29. #include <asm/io.h>
  30. #include <asm/irq.h>
  31. #include <asm/s390dyn.h>
  33. #include "dasd_int.h"
  34. #include "dasd_diag.h"
  36. #ifdef PRINTK_HEADER
  37. #undef PRINTK_HEADER
  38. #endif /* PRINTK_HEADER */
  39. #define PRINTK_HEADER DASD_NAME"(diag):"
  41. dasd_discipline_t dasd_diag_discipline;
  43. typedef struct
  44.     dasd_diag_private_t {
  45. dasd_diag_characteristics_t rdc_data;
  46. diag_rw_io_t iob;
  47. diag_init_io_t iib;
  48. unsigned long *label;
  49. } dasd_diag_private_t;
  51. static __inline__ int
  52. dia210 (void *devchar)
  53. {
  54. int rc;
  56. __asm__ __volatile__ ("    diag  %1,0,0x210n"
  57.       "0:  ipm   %0n"
  58.       "    srl   %0,28n"
  59.       "1:n"
  60.       ".section .fixup,"ax"n"
  61.       "2:  lhi   %0,3n"
  62.       "    bras  1,3fn"
  63.       "    .long 1bn"
  64.       "3:  l     1,0(1)n"
  65.       "    br    1n"
  66.       ".previousn"
  67.       ".section __ex_table,"a"n"
  68.       "    .align 4n"
  69.       "    .long 0b,2bn" ".previousn":"=d" (rc)
  70.       :"d" ((void *) __pa (devchar))
  71.       :"1");
  72. return rc;
  73. }
  75. static __inline__ int
  76. dia250 (void *iob, int cmd)
  77. {
  78. __asm__ __volatile__ ("    lr    0,%1n"
  79.       "    diag  0,%0,0x250n"
  80.       "0:  ipm   %0n"
  81.       "    srl   %0,28n"
  82.       "    or    %0,1n"
  83.       "1:n"
  84.       ".section .fixup,"ax"n"
  85.       "2:  lhi   %0,3n"
  86.       "    bras  1,3fn"
  87.       "    .long 1bn"
  88.       "3:  l     1,0(1)n"
  89.       "    br    1n"
  90.       ".previousn"
  91.       ".section __ex_table,"a"n"
  92.       "    .align 4n"
  93.       "    .long 0b,2bn" ".previousn":"+d" (cmd)
  94.       :"d" ((void *) __pa (iob))
  95.       :"0", "1", "cc");
  96. return cmd;
  97. }
  99. static __inline__ int
  100. mdsk_init_io (dasd_device_t * device, int blocksize, int offset, int size)
  101. {
  102. dasd_diag_private_t *private = (dasd_diag_private_t *) device->private;
  103. diag_init_io_t *iib = &private->iib;
  104. int rc;
  106. memset (iib, 0, sizeof (diag_init_io_t));
  108. iib->dev_nr = device->devinfo.devno;
  109. iib->block_size = blocksize;
  110. iib->offset = offset;
  111. iib->start_block = 0;
  112. iib->end_block = size;
  114. rc = dia250 (iib, INIT_BIO);
  116. return rc & 3;
  117. }
  119. static __inline__ int
  120. mdsk_term_io (dasd_device_t * device)
  121. {
  122. dasd_diag_private_t *private = (dasd_diag_private_t *) device->private;
  123. diag_init_io_t *iib = &private->iib;
  124. int rc;
  126. memset (iib, 0, sizeof (diag_init_io_t));
  127. iib->dev_nr = device->devinfo.devno;
  128. rc = dia250 (iib, TERM_BIO);
  129. return rc & 3;
  130. }
  132. int
  133. dasd_start_diag (ccw_req_t * cqr)
  134. {
  135. int rc;
  136. dasd_device_t *device = cqr->device;
  137. dasd_diag_private_t *private;
  138. diag_rw_io_t *iob;
  140. private = (dasd_diag_private_t *) device->private;
  141. iob = &private->iob;
  143. iob->dev_nr = device->devinfo.devno;
  144. iob->key = 0;
  145. iob->flags = 2;
  146. iob->block_count = cqr->cplength >> 1;
  147. iob->interrupt_params = (u32) cqr;
  148. iob->bio_list = __pa (cqr->cpaddr);
  150. asm volatile ("STCK %0":"=m" (cqr->startclk));
  151. rc = dia250 (iob, RW_BIO);
  152. if (rc > 8) {
  153. PRINT_WARN ("dia250 returned CC %dn", rc);
  154. check_then_set (&cqr->status,
  155. CQR_STATUS_QUEUED, CQR_STATUS_ERROR);
  156. } else if (rc == 0) {
  157. check_then_set (&cqr->status,
  158. CQR_STATUS_QUEUED, CQR_STATUS_DONE);
  159. dasd_schedule_bh (device);
  160. } else {
  161. check_then_set (&cqr->status,
  162. CQR_STATUS_QUEUED, CQR_STATUS_IN_IO);
  163. rc = 0;
  164. }
  165. return rc;
  166. }
  168. void
  169. dasd_ext_handler (struct pt_regs *regs, __u16 code)
  170. {
  171.      int cpu = smp_processor_id();
  172. ccw_req_t *cqr;
  173. int ip = S390_lowcore.ext_params;
  174. char status = *((char *) &S390_lowcore.ext_params + 5);
  175. dasd_device_t *device;
  176. int done_fast_io = 0;
  177. int devno;
  178.         unsigned long flags;
  181. irq_enter(cpu, -1);
  183. if (!ip) { /* no intparm: unsolicited interrupt */
  184. printk (KERN_WARNING PRINTK_HEADER
  185. "caught unsolicited interruptn");
  186. irq_exit(cpu, -1);
  187. return;
  188. }
  189. if (ip & 0x80000001) {
  190. printk (KERN_WARNING PRINTK_HEADER
  191. "caught spurious interrupt with parm %08xn", ip);
  192. irq_exit(cpu, -1);
  193. return;
  194. }
  195. cqr = (ccw_req_t *) ip;
  196. device = (dasd_device_t *) cqr->device;
  198. devno = device->devinfo.devno;
  199. if (device == NULL) {
  200. printk (KERN_WARNING PRINTK_HEADER
  201. " INT on devno 0x%04X  = /dev/%s (%d:%d)"
  202. " belongs to NULL devicen",
  203. devno, device->name, MAJOR (device->kdev),
  204. MINOR (device->kdev));
  205. }
  206. if (strncmp (device->discipline->ebcname, (char *) &cqr->magic, 4)) {
  207. printk (KERN_WARNING PRINTK_HEADER
  208. "0x%04X : /dev/%s (%d:%d)"
  209. " magic number of ccw_req_t 0x%08X doesn't match"
  210. " discipline 0x%08Xn",
  211. devno, device->name,
  212. MAJOR (device->kdev), MINOR (device->kdev),
  213. cqr->magic, *(int *) (&device->discipline->name));
  214. irq_exit(cpu, -1);
  215. return;
  216. }
  218.         /* get irq lock to modify request queue */
  219.         s390irq_spin_lock_irqsave (device->devinfo.irq, 
  220.                                    flags);
  222. asm volatile ("STCK %0":"=m" (cqr->stopclk));
  224. switch (status) {
  225. case 0x00:
  226. check_then_set (&cqr->status,
  227. CQR_STATUS_IN_IO, CQR_STATUS_DONE);
  228. if (cqr->next && (cqr->next->status == CQR_STATUS_QUEUED)) {
  229. if (dasd_start_diag (cqr->next) == 0) {
  230. done_fast_io = 1;
  231. }
  232. }
  233. break;
  234. case 0x01:
  235. case 0x02:
  236. case 0x03:
  237. default:
  238. check_then_set (&cqr->status,
  239. CQR_STATUS_IN_IO, CQR_STATUS_FAILED);
  240. break;
  241. }
  243.         s390irq_spin_unlock_irqrestore (device->devinfo.irq, 
  244.                                         flags);
  246. wake_up (&device->wait_q);
  247. dasd_schedule_bh (device);
  248. irq_exit(cpu, -1);
  250. }
  252. static int
  253. dasd_diag_check_characteristics (struct dasd_device_t *device)
  254. {
  255. int rc = 0;
  256. int bsize;
  257. int label_block;
  258. dasd_diag_private_t *private;
  259. dasd_diag_characteristics_t *rdc_data;
  260. ccw_req_t *cqr;
  261. long *label;
  262. int sb;
  264. if (device == NULL) {
  265. printk (KERN_WARNING PRINTK_HEADER
  266. "Null device pointer passed to characteristics checkern");
  267. return -ENODEV;
  268. }
  269. device->private = kmalloc (sizeof (dasd_diag_private_t), GFP_KERNEL);
  270. if (device->private == NULL) {
  271. printk (KERN_WARNING PRINTK_HEADER
  272. "memory allocation failed for private datan");
  273. rc = -ENOMEM;
  274.                 goto fail;
  275. }
  276. private = (dasd_diag_private_t *) device->private;
  277. rdc_data = (void *) &(private->rdc_data);
  279. rdc_data->dev_nr = device->devinfo.devno;
  280. rdc_data->rdc_len = sizeof (dasd_diag_characteristics_t);
  282.         rc = dia210 (rdc_data);
  283. if ( rc != 0) {
  284. goto fail;
  285. }
  286. if (rdc_data->vdev_class != DEV_CLASS_FBA &&
  287.     rdc_data->vdev_class != DEV_CLASS_ECKD &&
  288.     rdc_data->vdev_class != DEV_CLASS_CKD) {
  289.                 rc = -ENOTSUPP;
  290. goto fail;
  291. }
  292. #if 0
  293. printk (KERN_INFO PRINTK_HEADER
  294. "%04X: %04X on real %04X/%02Xn",
  295. rdc_data->dev_nr,
  296. rdc_data->vdev_type, rdc_data->rdev_type, rdc_data->rdev_model);
  297. #endif
  298. /* Figure out position of label block */
  299. if (private->rdc_data.vdev_class == DEV_CLASS_FBA) {
  300. device->sizes.pt_block = 1;
  301. } else if (private->rdc_data.vdev_class == DEV_CLASS_ECKD ||
  302.    private->rdc_data.vdev_class == DEV_CLASS_CKD) {
  303. device->sizes.pt_block = 2;
  304. } else {
  305.                 BUG();
  306. }
  307. private->label = (long *) get_free_page (GFP_KERNEL);
  308. label = private->label;
  309. mdsk_term_io (device); /* first terminate all outstanding operations */
  310. /* figure out blocksize of device */
  311. for (bsize = 512; bsize <= PAGE_SIZE; bsize <<= 1) {
  312. diag_bio_t *bio;
  313. diag_rw_io_t *iob = &private->iob;
  315. rc = mdsk_init_io (device, bsize, 0, 64);
  316. if (rc > 4) {
  317. continue;
  318. }
  319. cqr = dasd_alloc_request (dasd_diag_discipline.name,
  320.                                          sizeof (diag_bio_t) / sizeof (ccw1_t),
  321.                                          0, device);
  322. if (cqr == NULL) {
  323. printk (KERN_WARNING PRINTK_HEADER
  324. "No memory to allocate initialization requestn");
  325. free_page ((long) private->label);
  326.                         rc = -ENOMEM;
  327.                         goto fail;
  328. }
  329. bio = (diag_bio_t *) (cqr->cpaddr);
  330. memset (bio, 0, sizeof (diag_bio_t));
  331. bio->type = MDSK_READ_REQ;
  332. bio->block_number = device->sizes.pt_block + 1;
  333. bio->buffer = __pa (private->label);
  334. cqr->device = device;
  335. cqr->status = CQR_STATUS_FILLED;
  336. memset (iob, 0, sizeof (diag_rw_io_t));
  337. iob->dev_nr = rdc_data->dev_nr;
  338. iob->block_count = 1;
  339. iob->interrupt_params = (u32) cqr;
  340. iob->bio_list = __pa (bio);
  341. rc = dia250 (iob, RW_BIO);
  342. if (rc == 0) {
  343. if (label[3] != bsize ||
  344.                             label[0] != 0xc3d4e2f1 || /* != CMS1 */
  345.                             label[13] == 0 ){
  346.                                 rc = -EMEDIUMTYPE;
  347. goto fail;
  348. }
  349. break;
  350. }
  351. mdsk_term_io (device);
  352. }
  353.         if (bsize > PAGE_SIZE) {
  354.                 rc = -EMEDIUMTYPE;
  355. goto fail;
  356.         }
  357. device->sizes.blocks = label[7];
  358. device->sizes.bp_block = bsize;
  359. device->sizes.s2b_shift = 0; /* bits to shift 512 to get a block */
  360. for (sb = 512; sb < bsize; sb = sb << 1)
  361. device->sizes.s2b_shift++;
  362. printk (KERN_INFO PRINTK_HEADER
  363. "/dev/%s (%04X): capacity (%dkB blks): %ldkBn",
  364. device->name, device->devinfo.devno,
  365. (device->sizes.bp_block >> 10),
  366. (device->sizes.blocks << device->sizes.s2b_shift) >> 1);
  367. free_page ((long) private->label);
  368.         rc = 0;
  369. goto out;
  370.  fail:
  371.         if ( rc ) {
  372.                 kfree (device->private);
  373.                 device->private = NULL;
  374.         }
  375.  out:
  376. return rc;
  377. }
  379. static int
  380. dasd_diag_fill_geometry (struct dasd_device_t *device, struct hd_geometry *geo)
  381. {
  382. int rc = 0;
  383. dasd_diag_private_t *private = (dasd_diag_private_t *) device->private;
  384. unsigned long sectors = device->sizes.blocks << device->sizes.s2b_shift;
  385. unsigned long tracks = sectors >> 6;
  386. unsigned long trk_rem = sectors & ((1 << 6) - 1); /* 64k per track */
  387. unsigned long cyls = tracks >> 4;
  388. unsigned long cyls_rem = tracks & ((1 << 4) - 1); /* 16 head per cyl */
  390. switch (device->sizes.bp_block) {
  391. case 512:
  392. case 1024:
  393. case 2048:
  394. case 4096:
  395. break;
  396. default:
  397. return -EINVAL;
  398. }
  399. geo->cylinders = cyls;
  400. geo->heads = 16;
  401. geo->sectors = 128 >> device->sizes.s2b_shift;
  402. return rc;
  403. }
  405. static dasd_era_t
  406. dasd_diag_examine_error (ccw_req_t * cqr, devstat_t * stat)
  407. {
  408. return dasd_era_fatal;
  409. }
  411. static ccw_req_t *
  412. dasd_diag_build_cp_from_req (dasd_device_t * device, struct request *req)
  413. {
  414. ccw_req_t *rw_cp = NULL;
  415. struct buffer_head *bh;
  416. int rw_cmd;
  417. int noblk = req->nr_sectors >> device->sizes.s2b_shift;
  418. int byt_per_blk = device->sizes.bp_block;
  419. int block;
  420. diag_bio_t *bio;
  421. int bhct;
  422. long size;
  424. if (!noblk) {
  425. PRINT_ERR ("No blocks to read/write...returningn");
  426. return NULL;
  427. }
  428. if (req->cmd == READ) {
  429. rw_cmd = MDSK_READ_REQ;
  430. } else if (req->cmd == WRITE) {
  431. rw_cmd = MDSK_WRITE_REQ;
  432. }
  433. bhct = 0;
  434. for (bh = req->bh; bh; bh = bh->b_reqnext) {
  435. if (bh->b_size < byt_per_blk)
  436.                         BUG();
  437.                 bhct += bh->b_size >> (device->sizes.s2b_shift+9);
  438. }
  439. /* Build the request */
  440. rw_cp = dasd_alloc_request (dasd_diag_discipline.name, bhct << 1, 0, device);
  441. if (!rw_cp) {
  442. return NULL;
  443. }
  444. bio = (diag_bio_t *) (rw_cp->cpaddr);
  446. block = req->sector >> device->sizes.s2b_shift;
  447. for (bh = req->bh; bh; bh = bh->b_reqnext) {
  448.                 memset (bio, 0, sizeof (diag_bio_t));
  449.                 for (size = 0; size < bh->b_size; size += byt_per_blk) {
  450.                         bio->type = rw_cmd;
  451.                         bio->block_number = block + 1;
  452.                         bio->buffer = __pa (bh->b_data + size);
  453.                         bio++;
  454.                         block++;
  455.                 }
  456. }
  457. asm volatile ("STCK %0":"=m" (rw_cp->buildclk));
  458. rw_cp->device = device;
  459. rw_cp->expires = 50 * TOD_SEC; /* 50 seconds */
  460. rw_cp->req = req;
  461. check_then_set (&rw_cp->status, CQR_STATUS_EMPTY, CQR_STATUS_FILLED);
  462. return rw_cp;
  463. }
  465. static int
  466. dasd_diag_fill_info (dasd_device_t * device, dasd_information_t * info)
  467. {
  468. int rc = 0;
  469. info->FBA_layout = 1;
  470. info->characteristics_size = sizeof (dasd_diag_characteristics_t);
  471. memcpy (info->characteristics,
  472. &((dasd_diag_private_t *) device->private)->rdc_data,
  473. sizeof (dasd_diag_characteristics_t));
  474. info->confdata_size = 0;
  475. return rc;
  476. }
  478. static char *
  479. dasd_diag_dump_sense (struct dasd_device_t *device, ccw_req_t * req)
  480. {
  481. char *page = (char *) get_free_page (GFP_KERNEL);
  482. int len;
  483. if (page == NULL) {
  484. return NULL;
  485. }
  486. len = sprintf (page, KERN_WARNING PRINTK_HEADER
  487.        "device %04X on irq %d: I/O status report:n",
  488.        device->devinfo.devno, device->devinfo.irq);
  490. return page;
  491. }
  493. dasd_discipline_t dasd_diag_discipline = {
  494.         owner: THIS_MODULE,
  495. name:"DIAG",
  496. ebcname:"DIAG",
  497. max_blocks:PAGE_SIZE / sizeof (diag_bio_t),
  498. check_characteristics:dasd_diag_check_characteristics,
  499. fill_geometry:dasd_diag_fill_geometry,
  500. start_IO:dasd_start_diag,
  501. examine_error:dasd_diag_examine_error,
  502. build_cp_from_req:dasd_diag_build_cp_from_req,
  503. dump_sense:dasd_diag_dump_sense,
  504. int_handler:dasd_ext_handler,
  505. fill_info:dasd_diag_fill_info,
  506. };
  508. int
  509. dasd_diag_init (void)
  510. {
  511. int rc = 0;
  512. if (MACHINE_IS_VM) {
  513. printk (KERN_INFO PRINTK_HEADER
  514. "%s discipline initializingn",
  515. dasd_diag_discipline.name);
  516. ASCEBC (dasd_diag_discipline.ebcname, 4);
  517. ctl_set_bit (0, 9);
  518. register_external_interrupt (0x2603, dasd_ext_handler);
  519. dasd_discipline_add (&dasd_diag_discipline);
  520. } else {
  521. printk (KERN_INFO PRINTK_HEADER
  522. "Machine is not VM: %s discipline not initializingn",
  523. dasd_diag_discipline.name);
  524. rc = -EINVAL;
  525. }
  526. return rc;
  527. }
  529. void
  530. dasd_diag_cleanup (void)
  531. {
  532. if (MACHINE_IS_VM) {
  533. printk (KERN_INFO PRINTK_HEADER
  534. "%s discipline cleaning upn",
  535. dasd_diag_discipline.name);
  536. dasd_discipline_del (&dasd_diag_discipline);
  537. unregister_external_interrupt (0x2603, dasd_ext_handler);
  538. ctl_clear_bit (0, 9);
  539. } else {
  540. printk (KERN_INFO PRINTK_HEADER
  541. "Machine is not VM: %s discipline not initializingn",
  542. dasd_diag_discipline.name);
  543. }
  544. }
  546. #ifdef MODULE
  547. int
  548. init_module (void)
  549. {
  550. int rc = 0;
  551. rc = dasd_diag_init ();
  552. return rc;
  553. }
  555. void
  556. cleanup_module (void)
  557. {
  558. dasd_diag_cleanup ();
  559. return;
  560. }
  561. #endif
  563. /*
  564.  * Overrides for Emacs so that we follow Linus's tabbing style.
  565.  * Emacs will notice this stuff at the end of the file and automatically
  566.  * adjust the settings for this buffer only.  This must remain at the end
  567.  * of the file.
  568.  * ---------------------------------------------------------------------------
  569.  * Local variables:
  570.  * c-indent-level: 4 
  571.  * c-brace-imaginary-offset: 0
  572.  * c-brace-offset: -4
  573.  * c-argdecl-indent: 4
  574.  * c-label-offset: -4
  575.  * c-continued-statement-offset: 4
  576.  * c-continued-brace-offset: 0
  577.  * indent-tabs-mode: nil
  578.  * tab-width: 8
  579.  * End:
  580.  */