Lines Matching defs:shpnt
46 static int ibmmca_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start, off_t offset, int length, int inout);
509 struct Scsi_Host *shpnt = dev_get_drvdata(dev);
511 spin_lock_irqsave(shpnt->host_lock, flags);
513 if(!(inb(IM_STAT_REG(shpnt)) & IM_INTR_REQUEST)) {
514 spin_unlock_irqrestore(shpnt->host_lock, flags);
520 if ((reset_status(shpnt) == IM_RESET_NOT_IN_PROGRESS_NO_INT) || (reset_status(shpnt) == IM_RESET_FINISHED_OK_NO_INT)) {
521 reset_status(shpnt) = IM_RESET_NOT_IN_PROGRESS;
522 spin_unlock_irqrestore(shpnt->host_lock, flags);
528 if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY))
534 intr_reg = (unsigned char) (inb(IM_INTR_REG(shpnt)));
538 lastSCSI = last_scsi_command(shpnt)[ldn];
539 outb(IM_EOI | ldn, IM_ATTN_REG(shpnt));
549 printk(KERN_ERR " Last cmd=0x%x, ena=%x, len=", lastSCSI, ld(shpnt)[ldn].scb.enable);
550 if (ld(shpnt)[ldn].cmd)
551 printk("%ld/%ld,", (long) (scsi_bufflen(ld(shpnt)[ldn].cmd)), (long) (ld(shpnt)[ldn].scb.sys_buf_length));
554 if (ld(shpnt)[ldn].cmd)
555 printk("Blocksize=%d", ld(shpnt)[ldn].scb.u2.blk.length);
558 printk(", host=%p, ldn=0x%x\n", shpnt, ldn);
559 if (ld(shpnt)[ldn].cmd) {
560 printk(KERN_ERR "Blockcount=%d/%d\n", last_scsi_blockcount(shpnt)[ldn], ld(shpnt)[ldn].scb.u2.blk.count);
561 printk(KERN_ERR "Logical block=%lx/%lx\n", last_scsi_logical_block(shpnt)[ldn], ld(shpnt)[ldn].scb.u1.log_blk_adr);
566 printk(KERN_ERR " Command Type................: %x\n", last_scsi_type(shpnt)[ldn]);
567 printk(KERN_ERR " Attention Register..........: %x\n", inb(IM_ATTN_REG(shpnt)));
568 printk(KERN_ERR " Basic Control Register......: %x\n", inb(IM_CTR_REG(shpnt)));
570 printk(KERN_ERR " Basic Status Register.......: %x\n", inb(IM_STAT_REG(shpnt)));
571 if ((last_scsi_type(shpnt)[ldn] == IM_SCB) || (last_scsi_type(shpnt)[ldn] == IM_LONG_SCB)) {
572 printk(KERN_ERR " SCB-Command.................: %x\n", ld(shpnt)[ldn].scb.command);
573 printk(KERN_ERR " SCB-Enable..................: %x\n", ld(shpnt)[ldn].scb.enable);
574 printk(KERN_ERR " SCB-logical block address...: %lx\n", ld(shpnt)[ldn].scb.u1.log_blk_adr);
575 printk(KERN_ERR " SCB-system buffer address...: %lx\n", ld(shpnt)[ldn].scb.sys_buf_adr);
576 printk(KERN_ERR " SCB-system buffer length....: %lx\n", ld(shpnt)[ldn].scb.sys_buf_length);
577 printk(KERN_ERR " SCB-tsb address.............: %lx\n", ld(shpnt)[ldn].scb.tsb_adr);
578 printk(KERN_ERR " SCB-Chain address...........: %lx\n", ld(shpnt)[ldn].scb.scb_chain_adr);
579 printk(KERN_ERR " SCB-block count.............: %x\n", ld(shpnt)[ldn].scb.u2.blk.count);
580 printk(KERN_ERR " SCB-block length............: %x\n", ld(shpnt)[ldn].scb.u2.blk.length);
602 IBM_DS(shpnt).total_interrupts++;
604 if (local_checking_phase_flag(shpnt)) {
605 stat_result(shpnt) = cmd_result;
606 got_interrupt(shpnt) = 1;
607 reset_status(shpnt) = IM_RESET_FINISHED_OK;
608 last_scsi_command(shpnt)[ldn] = NO_SCSI;
609 spin_unlock_irqrestore(shpnt->host_lock, flags);
613 if (last_scsi_type(shpnt)[ldn] == IM_IMM_CMD) {
615 if ((reset_status(shpnt) == IM_RESET_IN_PROGRESS) && (last_scsi_command(shpnt)[ldn] == IM_RESET_IMM_CMD)) {
619 reset_status(shpnt) = IM_RESET_FINISHED_FAIL;
624 reset_status(shpnt) = IM_RESET_FINISHED_OK;
626 stat_result(shpnt) = cmd_result;
627 last_scsi_command(shpnt)[ldn] = NO_SCSI;
628 last_scsi_type(shpnt)[ldn] = 0;
629 spin_unlock_irqrestore(shpnt->host_lock, flags);
631 } else if (last_scsi_command(shpnt)[ldn] == IM_ABORT_IMM_CMD) {
638 cmd = ld(shpnt)[ldn].cmd;
639 ld(shpnt)[ldn].cmd = NULL;
644 stat_result(shpnt) = cmd_result;
645 last_scsi_command(shpnt)[ldn] = NO_SCSI;
646 last_scsi_type(shpnt)[ldn] = 0;
649 spin_unlock_irqrestore(shpnt->host_lock, flags);
654 reset_status(shpnt) = IM_RESET_FINISHED_OK;
655 stat_result(shpnt) = cmd_result;
656 last_scsi_command(shpnt)[ldn] = NO_SCSI;
657 spin_unlock_irqrestore(shpnt->host_lock, flags);
661 last_scsi_command(shpnt)[ldn] = NO_SCSI;
662 last_scsi_type(shpnt)[ldn] = 0;
663 cmd = ld(shpnt)[ldn].cmd;
664 ld(shpnt)[ldn].cmd = NULL;
668 spin_unlock_irqsave(shpnt->host_lock, flags);
677 spin_unlock_irqrestore(shpnt->host_lock, flags);
682 printk("cmd=%02x ireg=%02x ds=%02x cs=%02x de=%02x ce=%02x\n", cmd->cmnd[0], intr_reg, ld(shpnt)[ldn].tsb.dev_status, ld(shpnt)[ldn].tsb.cmd_status, ld(shpnt)[ldn].tsb.dev_error, ld(shpnt)[ldn].tsb.cmd_error);
685 if ((ld(shpnt)[ldn].device_type != TYPE_NO_LUN) && (ld(shpnt)[ldn].device_type != TYPE_NO_DEVICE)) {
696 cmd->result = (unsigned char) (ld(shpnt)[ldn].tsb.dev_status & 0x1e);
697 IBM_DS(shpnt).total_errors++;
708 spin_unlock_irqrestore(shpnt->host_lock, flags);
712 static void issue_cmd(struct Scsi_Host *shpnt, unsigned long cmd_reg,
718 spin_lock_irqsave(shpnt->host_lock, flags);
719 if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY))
721 spin_unlock_irqrestore(shpnt->host_lock, flags);
724 outl(cmd_reg, IM_CMD_REG(shpnt));
725 outb(attn_reg, IM_ATTN_REG(shpnt));
726 spin_unlock_irqrestore(shpnt->host_lock, flags);
736 static int device_inquiry(struct Scsi_Host *shpnt, int ldn)
743 scb = &(ld(shpnt)[ldn].scb);
744 tsb = &(ld(shpnt)[ldn].tsb);
745 buf = (unsigned char *) (&(ld(shpnt)[ldn].buf));
746 ld(shpnt)[ldn].tsb.dev_status = 0; /* prepare statusblock */
751 last_scsi_command(shpnt)[ldn] = IM_DEVICE_INQUIRY_CMD;
752 last_scsi_type(shpnt)[ldn] = IM_SCB;
757 got_interrupt(shpnt) = 0;
758 issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | ldn);
759 while (!got_interrupt(shpnt))
763 if ((stat_result(shpnt) == IM_SCB_CMD_COMPLETED) || (stat_result(shpnt) == IM_SCB_CMD_COMPLETED_WITH_RETRIES))
773 static int read_capacity(struct Scsi_Host *shpnt, int ldn)
780 scb = &(ld(shpnt)[ldn].scb);
781 tsb = &(ld(shpnt)[ldn].tsb);
782 buf = (unsigned char *) (&(ld(shpnt)[ldn].buf));
783 ld(shpnt)[ldn].tsb.dev_status = 0;
788 last_scsi_command(shpnt)[ldn] = IM_READ_CAPACITY_CMD;
789 last_scsi_type(shpnt)[ldn] = IM_SCB;
794 got_interrupt(shpnt) = 0;
795 issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | ldn);
796 while (!got_interrupt(shpnt))
800 if ((stat_result(shpnt) == IM_SCB_CMD_COMPLETED) || (stat_result(shpnt) == IM_SCB_CMD_COMPLETED_WITH_RETRIES))
810 static int get_pos_info(struct Scsi_Host *shpnt)
817 scb = &(ld(shpnt)[MAX_LOG_DEV].scb);
818 tsb = &(ld(shpnt)[MAX_LOG_DEV].tsb);
819 buf = (unsigned char *) (&(ld(shpnt)[MAX_LOG_DEV].buf));
820 ld(shpnt)[MAX_LOG_DEV].tsb.dev_status = 0;
825 last_scsi_command(shpnt)[MAX_LOG_DEV] = IM_GET_POS_INFO_CMD;
826 last_scsi_type(shpnt)[MAX_LOG_DEV] = IM_SCB;
828 if (special(shpnt) == IBM_SCSI2_FW)
834 got_interrupt(shpnt) = 0;
835 issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | MAX_LOG_DEV);
837 while (!got_interrupt(shpnt))
841 if ((stat_result(shpnt) == IM_SCB_CMD_COMPLETED) || (stat_result(shpnt) == IM_SCB_CMD_COMPLETED_WITH_RETRIES))
854 static int immediate_assign(struct Scsi_Host *shpnt, unsigned int pun,
863 switch (special(shpnt)) {
872 imm_cmd = inl(IM_CMD_REG(shpnt));
881 last_scsi_command(shpnt)[MAX_LOG_DEV] = IM_ASSIGN_IMM_CMD;
882 last_scsi_type(shpnt)[MAX_LOG_DEV] = IM_IMM_CMD;
883 got_interrupt(shpnt) = 0;
884 issue_cmd(shpnt, (unsigned long) (imm_cmd), IM_IMM_CMD | MAX_LOG_DEV);
885 while (!got_interrupt(shpnt))
889 if (stat_result(shpnt) == IM_IMMEDIATE_CMD_COMPLETED)
898 static int immediate_feature(struct Scsi_Host *shpnt, unsigned int speed, unsigned int timeout)
908 last_scsi_command(shpnt)[MAX_LOG_DEV] = IM_FEATURE_CTR_IMM_CMD;
909 last_scsi_type(shpnt)[MAX_LOG_DEV] = IM_IMM_CMD;
910 got_interrupt(shpnt) = 0;
914 issue_cmd(shpnt, (unsigned long) (imm_cmd), IM_IMM_CMD | MAX_LOG_DEV);
916 while (!got_interrupt(shpnt))
924 if (stat_result(shpnt) == IM_IMMEDIATE_CMD_COMPLETED)
934 static int immediate_reset(struct Scsi_Host *shpnt, unsigned int ldn)
941 imm_command = inl(IM_CMD_REG(shpnt));
944 last_scsi_command(shpnt)[ldn] = IM_RESET_IMM_CMD;
945 last_scsi_type(shpnt)[ldn] = IM_IMM_CMD;
946 got_interrupt(shpnt) = 0;
947 reset_status(shpnt) = IM_RESET_IN_PROGRESS;
948 issue_cmd(shpnt, (unsigned long) (imm_command), IM_IMM_CMD | ldn);
950 while (reset_status(shpnt) == IM_RESET_IN_PROGRESS && --ticks) {
957 reset_status(shpnt) = IM_RESET_FINISHED_OK;
962 if (stat_result(shpnt) == IM_IMMEDIATE_CMD_COMPLETED)
1064 static int probe_bus_mode(struct Scsi_Host *shpnt)
1070 info = (struct im_pos_info *) (&(ld(shpnt)[MAX_LOG_DEV].buf));
1071 if (get_pos_info(shpnt)) {
1073 subsystem_connector_size(shpnt) = 16;
1075 subsystem_connector_size(shpnt) = 32;
1078 if ((special(shpnt) == IBM_SCSI_WCACHE) || (special(shpnt) == IBM_7568_WCACHE)) {
1080 ld(shpnt)[ldn].cache_flag = 0;
1083 ld(shpnt)[ldn].retry_flag = 0;
1088 printk("%d", ld(shpnt)[ldn].cache_flag);
1092 printk("%d", ld(shpnt)[ldn].retry_flag);
1101 static void check_devices(struct Scsi_Host *shpnt, int adaptertype)
1112 IBM_DS(shpnt).dyn_flag = 0; /* normally no need for dynamical ldn management */
1113 IBM_DS(shpnt).total_errors = 0; /* set errorcounter to 0 */
1114 next_ldn(shpnt) = 7; /* next ldn to be assigned is 7, because 0-6 is 'hardwired' */
1117 memset(ld(shpnt), 0, sizeof(ld(shpnt)));
1119 last_scsi_command(shpnt)[ldn] = NO_SCSI; /* emptify last SCSI-command storage */
1120 last_scsi_type(shpnt)[ldn] = 0;
1121 ld(shpnt)[ldn].cache_flag = 1;
1122 ld(shpnt)[ldn].retry_flag = 1;
1124 memset(get_ldn(shpnt), TYPE_NO_DEVICE, sizeof(get_ldn(shpnt))); /* this is essential ! */
1125 memset(get_scsi(shpnt), TYPE_NO_DEVICE, sizeof(get_scsi(shpnt))); /* this is essential ! */
1128 get_scsi(shpnt)[subsystem_pun(shpnt)][lun] = TYPE_IBM_SCSI_ADAPTER;
1129 get_ldn(shpnt)[subsystem_pun(shpnt)][lun] = MAX_LOG_DEV; /* make sure, the subsystem
1138 adapter_speed(shpnt) = global_adapter_speed;
1139 speedrun = adapter_speed(shpnt);
1140 while (immediate_feature(shpnt, speedrun, adapter_timeout) == 2) {
1148 adapter_speed(shpnt) = speedrun;
1151 num_bus = probe_bus_mode(shpnt);
1158 subsystem_maxid(shpnt) = 16;
1161 subsystem_maxid(shpnt) = 8;
1168 max_pun = subsystem_maxid(shpnt);
1171 printk("IBM MCA SCSI: Current SCSI-host index: %d\n", shpnt);
1181 immediate_assign(shpnt, 0, 0, ldn, REMOVE_LDN); /* remove ldn (wherever) */
1200 if (id != subsystem_pun(shpnt)) {
1203 immediate_assign(shpnt, id, lun, PROBE_LDN, SET_LDN);
1204 if (device_inquiry(shpnt, PROBE_LDN)) { /* probe device */
1205 get_scsi(shpnt)[id][lun] = (unsigned char) (ld(shpnt)[PROBE_LDN].buf[0]);
1207 if (ld(shpnt)[PROBE_LDN].buf[0] != TYPE_NO_LUN)
1211 immediate_assign(shpnt, id, lun, PROBE_LDN, REMOVE_LDN);
1231 if (id != subsystem_pun(shpnt)) {
1232 if (get_scsi(shpnt)[id][lun] != TYPE_NO_LUN && get_scsi(shpnt)[id][lun] != TYPE_NO_DEVICE) {
1235 immediate_assign(shpnt, id, lun, ldn, SET_LDN);
1236 get_ldn(shpnt)[id][lun] = ldn; /* map ldn */
1237 if (device_exists(shpnt, ldn, &ld(shpnt)[ldn].block_length, &ld(shpnt)[ldn].device_type)) {
1240 immediate_reset(shpnt, ldn);
1248 get_ldn(shpnt)[id][lun] = TYPE_NO_DEVICE;
1249 immediate_assign(shpnt, 0, 0, ldn, REMOVE_LDN);
1255 immediate_assign(shpnt, id, lun, ldn, SET_LDN);
1256 get_ldn(shpnt)[id][lun] = ldn; /* map ldn */
1266 if (get_scsi(shpnt)[id][lun] == TYPE_NO_LUN || get_scsi(shpnt)[id][lun] == TYPE_NO_DEVICE) {
1272 immediate_assign(shpnt, id, lun, ldn, SET_LDN);
1273 get_ldn(shpnt)[id][lun] = ldn;
1296 printk("%2s ", ti_p(get_scsi(shpnt)[id][lun]));
1299 printk("%2s ", ti_l(get_ldn(shpnt)[id][lun]));
1305 IBM_DS(shpnt).total_scsi_devices = count_devices;
1310 IBM_DS(shpnt).dyn_flag = 1; /* dynamical assignment is necessary */
1312 IBM_DS(shpnt).dyn_flag = 0; /* dynamical assignment is not necessary */
1319 IBM_DS(shpnt).scbs = 0;
1320 IBM_DS(shpnt).long_scbs = 0;
1321 IBM_DS(shpnt).total_accesses = 0;
1322 IBM_DS(shpnt).total_interrupts = 0;
1323 IBM_DS(shpnt).dynamical_assignments = 0;
1324 memset(IBM_DS(shpnt).ldn_access, 0x0, sizeof(IBM_DS(shpnt).ldn_access));
1325 memset(IBM_DS(shpnt).ldn_read_access, 0x0, sizeof(IBM_DS(shpnt).ldn_read_access));
1326 memset(IBM_DS(shpnt).ldn_write_access, 0x0, sizeof(IBM_DS(shpnt).ldn_write_access));
1327 memset(IBM_DS(shpnt).ldn_inquiry_access, 0x0, sizeof(IBM_DS(shpnt).ldn_inquiry_access));
1328 memset(IBM_DS(shpnt).ldn_modeselect_access, 0x0, sizeof(IBM_DS(shpnt).ldn_modeselect_access));
1329 memset(IBM_DS(shpnt).ldn_assignments, 0x0, sizeof(IBM_DS(shpnt).ldn_assignments));
1334 static int device_exists(struct Scsi_Host *shpnt, int ldn, int *block_length, int *device_type)
1338 if (!(device_inquiry(shpnt, ldn)))
1340 buf = (unsigned char *) (&(ld(shpnt)[ldn].buf));
1353 if (read_capacity(shpnt, ldn)) {
1361 if (read_capacity(shpnt, ldn)) {
1452 struct Scsi_Host *shpnt;
1559 shpnt = scsi_host_alloc(&ibmmca_driver_template,
1561 if (!shpnt) {
1566 dev_set_drvdata(dev, shpnt);
1573 special(shpnt) = mca_dev->index; /* important assignment or else crash! */
1574 subsystem_connector_size(shpnt) = 0; /* preset slot-size */
1575 shpnt->irq = irq; /* assign necessary stuff for the adapter */
1576 shpnt->io_port = port;
1577 shpnt->n_io_port = IM_N_IO_PORT;
1578 shpnt->this_id = id;
1579 shpnt->max_id = 8; /* 8 PUNs are default */
1590 reset_status(shpnt) = IM_RESET_NOT_IN_PROGRESS;
1594 get_ldn(shpnt)[i][j] = MAX_LOG_DEV;
1598 local_checking_phase_flag(shpnt) = 1;
1599 check_devices(shpnt, mca_dev->index); /* call by value, using the global variable hosts */
1600 local_checking_phase_flag(shpnt) = 0;
1605 ((struct ibmmca_hostdata *) shpnt->hostdata)->_pos[k] = pos[k];
1606 ((struct ibmmca_hostdata *) shpnt->hostdata)->_special = INTEGRATED_SCSI;
1609 if (scsi_add_host(shpnt, dev)) {
1613 scsi_scan_host(shpnt);
1617 scsi_host_put(shpnt);
1626 struct Scsi_Host *shpnt = dev_get_drvdata(dev);
1627 scsi_remove_host(shpnt);
1628 release_region(shpnt->io_port, shpnt->n_io_port);
1629 free_irq(shpnt->irq, dev);
1630 scsi_host_put(shpnt);
1640 struct Scsi_Host *shpnt;
1648 shpnt = cmd->device->host;
1650 max_pun = subsystem_maxid(shpnt);
1653 if ((target <= subsystem_pun(shpnt)) && (cmd->device->id <= subsystem_pun(shpnt)))
1655 else if ((target >= subsystem_pun(shpnt)) && (cmd->device->id >= subsystem_pun(shpnt)))
1661 if ((get_scsi(shpnt)[target][cmd->device->lun] == TYPE_NO_LUN) || (get_scsi(shpnt)[target][cmd->device->lun] == TYPE_NO_DEVICE)) {
1669 ldn = get_ldn(shpnt)[target][cmd->device->lun];
1672 current_ldn = next_ldn(shpnt); /* stop-value for one circle */
1673 while (ld(shpnt)[next_ldn(shpnt)].cmd) { /* search for a occupied, but not in */
1675 next_ldn(shpnt)++;
1676 if (next_ldn(shpnt) >= MAX_LOG_DEV)
1677 next_ldn(shpnt) = 7;
1678 if (current_ldn == next_ldn(shpnt)) { /* One circle done ? */
1694 if (get_ldn(shpnt)[id][lun] == next_ldn(shpnt)) {
1695 get_ldn(shpnt)[id][lun] = TYPE_NO_DEVICE;
1696 get_scsi(shpnt)[id][lun] = TYPE_NO_DEVICE;
1701 local_checking_phase_flag(shpnt) = 1;
1703 get_ldn(shpnt)[target][cmd->device->lun] = next_ldn(shpnt);
1705 ldn = next_ldn(shpnt);
1707 immediate_assign(shpnt, 0, 0, 0, REMOVE_LDN);
1709 immediate_assign(shpnt, target, cmd->device->lun, ldn, SET_LDN);
1711 if (device_exists(shpnt, ldn, &ld(shpnt)[ldn].block_length, &ld(shpnt)[ldn].device_type)) {
1712 ld(shpnt)[ldn].cmd = NULL; /* To prevent panic set 0, because
1715 get_scsi(shpnt)[target][cmd->device->lun] = ld(shpnt)[ldn].device_type;
1717 IBM_DS(shpnt).dynamical_assignments++;
1718 IBM_DS(shpnt).ldn_assignments[ldn]++;
1724 immediate_assign(shpnt, 0, 0, 0, REMOVE_LDN);
1731 if (get_ldn(shpnt)[id][lun] <= MAX_LOG_DEV)
1732 immediate_assign(shpnt, id, lun, get_ldn(shpnt)[id][lun], SET_LDN);
1735 local_checking_phase_flag(shpnt) = 0;
1741 next_ldn(shpnt)++;
1742 if (next_ldn(shpnt) >= MAX_LOG_DEV)
1743 next_ldn(shpnt) = 7;
1753 if (ld(shpnt)[ldn].cmd)
1758 ld(shpnt)[ldn].cmd = cmd;
1761 scb = &(ld(shpnt)[ldn].scb);
1762 ld(shpnt)[ldn].tsb.dev_status = 0;
1764 scb->tsb_adr = isa_virt_to_bus(&(ld(shpnt)[ldn].tsb));
1771 ld(shpnt)[ldn].sge[i].address = (void *) (isa_page_to_bus(sg_page(sg)) + sg->offset);
1772 ld(shpnt)[ldn].sge[i].byte_length = sg->length;
1775 scb->sys_buf_adr = isa_virt_to_bus(&(ld(shpnt)[ldn].sge[0]));
1810 if (ld(shpnt)[ldn].device_type == IM_DEBUG_CMD_DEVICE)
1811 printk("(SCSI-device-type=0x%x) issue scsi cmd=%02x to ldn=%d\n", ld(shpnt)[ldn].device_type, scsi_cmd, ldn);
1815 last_scsi_command(shpnt)[ldn] = scsi_cmd;
1816 last_scsi_type(shpnt)[ldn] = IM_SCB;
1818 IBM_DS(shpnt).total_accesses++;
1819 IBM_DS(shpnt).ldn_access[ldn]++;
1831 switch (ld(shpnt)[ldn].device_type) {
1838 IBM_DS(shpnt).ldn_read_access[ldn]++; /* increase READ-access on ldn stat. */
1841 IBM_DS(shpnt).ldn_write_access[ldn]++; /* increase write-count on ldn stat. */
1851 last_scsi_logical_block(shpnt)[ldn] = scb->u1.log_blk_adr;
1852 last_scsi_blockcount(shpnt)[ldn] = scb->u2.blk.count;
1853 scb->u2.blk.length = ld(shpnt)[ldn].block_length;
1874 last_scsi_type(shpnt)[ldn] = IM_LONG_SCB;
1881 IBM_DS(shpnt).ldn_inquiry_access[ldn]++;
1892 last_scsi_type(shpnt)[ldn] = IM_LONG_SCB;
1909 IBM_DS(shpnt).ldn_modeselect_access[ldn]++;
1914 last_scsi_type(shpnt)[ldn] = IM_LONG_SCB;
1923 last_scsi_type(shpnt)[ldn] = IM_LONG_SCB;
1928 PS2_DISK_LED_ON(shpnt->host_no, target);
1930 if (last_scsi_type(shpnt)[ldn] == IM_LONG_SCB) {
1931 issue_cmd(shpnt, isa_virt_to_bus(scb), IM_LONG_SCB | ldn);
1932 IBM_DS(shpnt).long_scbs++;
1934 issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | ldn);
1935 IBM_DS(shpnt).scbs++;
1946 struct Scsi_Host *shpnt;
1957 shpnt = cmd->device->host;
1959 max_pun = subsystem_maxid(shpnt);
1962 if ((target <= subsystem_pun(shpnt)) && (cmd->device->id <= subsystem_pun(shpnt)))
1964 else if ((target >= subsystem_pun(shpnt)) && (cmd->device->id >= subsystem_pun(shpnt)))
1971 ldn = get_ldn(shpnt)[target][cmd->device->lun];
1974 if (!ld(shpnt)[ldn].cmd) {
1985 last_scsi_command(shpnt)[ldn] = IM_ABORT_IMM_CMD;
1986 last_scsi_type(shpnt)[ldn] = IM_IMM_CMD;
1987 imm_command = inl(IM_CMD_REG(shpnt));
1992 if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY))
1996 outl(imm_command, IM_CMD_REG(shpnt));
1997 outb(IM_IMM_CMD | ldn, IM_ATTN_REG(shpnt));
2001 spin_unlock_irq(shpnt->host_lock);
2004 spin_lock_irq(shpnt->host_lock);
2016 ld(shpnt)[ldn].cmd = NULL;
2025 ld(shpnt)[ldn].cmd = NULL;
2035 struct Scsi_Host *shpnt = cmd->device->host;
2038 spin_lock_irq(shpnt->host_lock);
2040 spin_unlock_irq(shpnt->host_lock);
2047 struct Scsi_Host *shpnt;
2055 shpnt = cmd->device->host;
2057 if (local_checking_phase_flag(shpnt)) {
2064 reset_status(shpnt) = IM_RESET_IN_PROGRESS;
2065 last_scsi_command(shpnt)[0xf] = IM_RESET_IMM_CMD;
2066 last_scsi_type(shpnt)[0xf] = IM_IMM_CMD;
2067 imm_command = inl(IM_CMD_REG(shpnt));
2072 if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY))
2074 spin_unlock_irq(shpnt->host_lock);
2076 spin_lock_irq(shpnt->host_lock);
2079 outl(imm_command, IM_CMD_REG(shpnt));
2080 outb(IM_IMM_CMD | 0xf, IM_ATTN_REG(shpnt));
2084 while (reset_status(shpnt) == IM_RESET_IN_PROGRESS && --ticks && ((inb(IM_INTR_REG(shpnt)) & 0x8f) != 0x8f)) {
2091 reset_status(shpnt) = IM_RESET_FINISHED_FAIL;
2095 if ((inb(IM_INTR_REG(shpnt)) & 0x8f) == 0x8f) {
2097 if (inb(IM_INTR_REG(shpnt)) == 0xaf)
2098 reset_status(shpnt) = IM_RESET_FINISHED_OK_NO_INT;
2099 else if (inb(IM_INTR_REG(shpnt)) == 0xcf)
2100 reset_status(shpnt) = IM_RESET_FINISHED_FAIL;
2102 reset_status(shpnt) = IM_RESET_NOT_IN_PROGRESS_NO_INT;
2103 outb(IM_EOI | 0xf, IM_ATTN_REG(shpnt));
2107 if (reset_status(shpnt) == IM_RESET_FINISHED_FAIL) {
2115 cmd_aid = ld(shpnt)[i].cmd;
2117 ld(shpnt)[i].cmd = NULL;
2126 struct Scsi_Host *shpnt = cmd->device->host;
2129 spin_lock_irq(shpnt->host_lock);
2131 spin_unlock_irq(shpnt->host_lock);
2158 static int ldn_access_load(struct Scsi_Host *shpnt, int ldn)
2160 if (IBM_DS(shpnt).total_accesses == 0)
2162 if (IBM_DS(shpnt).ldn_access[ldn] == 0)
2164 return (IBM_DS(shpnt).ldn_access[ldn] * 100) / IBM_DS(shpnt).total_accesses;
2168 static int ldn_access_total_read_write(struct Scsi_Host *shpnt)
2175 a += IBM_DS(shpnt).ldn_read_access[i] + IBM_DS(shpnt).ldn_write_access[i];
2179 static int ldn_access_total_inquiry(struct Scsi_Host *shpnt)
2186 a += IBM_DS(shpnt).ldn_inquiry_access[i];
2190 static int ldn_access_total_modeselect(struct Scsi_Host *shpnt)
2197 a += IBM_DS(shpnt).ldn_modeselect_access[i];
2202 static int ibmmca_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start, off_t offset, int length, int inout)
2210 spin_lock_irqsave(shpnt->host_lock, flags); /* Check it */
2212 max_pun = subsystem_maxid(shpnt);
2222 len += sprintf(buffer + len, " This Hostnumber..........: %d\n", shpnt->host_no);
2223 len += sprintf(buffer + len, " Base I/O-Port............: 0x%x\n", (unsigned int) (IM_CMD_REG(shpnt)));
2225 len += sprintf(buffer + len, " Total Interrupts.........: %d\n", IBM_DS(shpnt).total_interrupts);
2226 len += sprintf(buffer + len, " Total SCSI Accesses......: %d\n", IBM_DS(shpnt).total_accesses);
2227 len += sprintf(buffer + len, " Total short SCBs.........: %d\n", IBM_DS(shpnt).scbs);
2228 len += sprintf(buffer + len, " Total long SCBs..........: %d\n", IBM_DS(shpnt).long_scbs);
2229 len += sprintf(buffer + len, " Total SCSI READ/WRITE..: %d\n", ldn_access_total_read_write(shpnt));
2230 len += sprintf(buffer + len, " Total SCSI Inquiries...: %d\n", ldn_access_total_inquiry(shpnt));
2231 len += sprintf(buffer + len, " Total SCSI Modeselects.: %d\n", ldn_access_total_modeselect(shpnt));
2232 len += sprintf(buffer + len, " Total SCSI other cmds..: %d\n", IBM_DS(shpnt).total_accesses - ldn_access_total_read_write(shpnt)
2233 - ldn_access_total_modeselect(shpnt)
2234 - ldn_access_total_inquiry(shpnt));
2235 len += sprintf(buffer + len, " Total SCSI command fails.: %d\n\n", IBM_DS(shpnt).total_errors);
2240 len += sprintf(buffer + len, " %2X | %3d | %8d | %8d | %8d\n", i, ldn_access_load(shpnt, i), IBM_DS(shpnt).ldn_read_access[i], IBM_DS(shpnt).ldn_write_access[i], IBM_DS(shpnt).ldn_assignments[i]);
2243 len += sprintf(buffer + len, " Number of physical SCSI-devices..: %d (+ Adapter)\n", IBM_DS(shpnt).total_scsi_devices);
2244 len += sprintf(buffer + len, " Dynamical Assignment necessary...: %s\n", IBM_DS(shpnt).dyn_flag ? "Yes" : "No ");
2245 len += sprintf(buffer + len, " Next LDN to be assigned..........: 0x%x\n", next_ldn(shpnt));
2246 len += sprintf(buffer + len, " Dynamical assignments done yet...: %d\n", IBM_DS(shpnt).dynamical_assignments);
2253 len += sprintf(buffer + len, "%2s ", ti_p(get_scsi(shpnt)[id][lun]));
2256 len += sprintf(buffer + len, "%2s ", ti_l(get_ldn(shpnt)[id][lun]));
2268 spin_unlock_irqrestore(shpnt->host_lock, flags);