[linux-2.6-block.git] / drivers / scsi / gdth_proc.c

// SPDX-License-Identifier: GPL-2.0
/* gdth_proc.c 
 * $Id: gdth_proc.c,v 1.43 2006/01/11 16:15:00 achim Exp $
 */

#include <linux/completion.h>
#include <linux/slab.h>

int gdth_set_info(struct Scsi_Host *host, char *buffer, int length)
{
    gdth_ha_str *ha = shost_priv(host);
    int ret_val = -EINVAL;

    TRACE2(("gdth_set_info() ha %d\n",ha->hanum,));

    if (length >= 4) {
        if (strncmp(buffer,"gdth",4) == 0) {
            buffer += 5;
            length -= 5;
            ret_val = gdth_set_asc_info(host, buffer, length, ha);
        }
    }

    return ret_val;
}
         
static int gdth_set_asc_info(struct Scsi_Host *host, char *buffer,
                        int length, gdth_ha_str *ha)
{
    int orig_length, drive, wb_mode;
    int i, found;
    gdth_cmd_str    gdtcmd;
    gdth_cpar_str   *pcpar;

    char            cmnd[MAX_COMMAND_SIZE];
    memset(cmnd, 0xff, 12);
    memset(&gdtcmd, 0, sizeof(gdth_cmd_str));

    TRACE2(("gdth_set_asc_info() ha %d\n",ha->hanum));
    orig_length = length + 5;
    drive = -1;
    wb_mode = 0;
    found = FALSE;

    if (length >= 5 && strncmp(buffer,"flush",5)==0) {
        buffer += 6;
        length -= 6;
        if (length && *buffer>='0' && *buffer<='9') {
            drive = (int)(*buffer-'0');
            ++buffer; --length;
            if (length && *buffer>='0' && *buffer<='9') {
                drive = drive*10 + (int)(*buffer-'0');
                ++buffer; --length;
            }
            printk("GDT: Flushing host drive %d .. ",drive);
        } else {
            printk("GDT: Flushing all host drives .. ");
        }
        for (i = 0; i < MAX_HDRIVES; ++i) {
            if (ha->hdr[i].present) {
                if (drive != -1 && i != drive)
                    continue;
                found = TRUE;
                gdtcmd.Service = CACHESERVICE;
                gdtcmd.OpCode = GDT_FLUSH;
                if (ha->cache_feat & GDT_64BIT) {
                    gdtcmd.u.cache64.DeviceNo = i;
                    gdtcmd.u.cache64.BlockNo = 1;
                } else {
                    gdtcmd.u.cache.DeviceNo = i;
                    gdtcmd.u.cache.BlockNo = 1;
                }

                gdth_execute(host, &gdtcmd, cmnd, 30, NULL);
            }
        }
        if (!found)
            printk("\nNo host drive found !\n");
        else
            printk("Done.\n");
        return(orig_length);
    }

    if (length >= 7 && strncmp(buffer,"wbp_off",7)==0) {
        buffer += 8;
        length -= 8;
        printk("GDT: Disabling write back permanently .. ");
        wb_mode = 1;
    } else if (length >= 6 && strncmp(buffer,"wbp_on",6)==0) {
        buffer += 7;
        length -= 7;
        printk("GDT: Enabling write back permanently .. ");
        wb_mode = 2;
    } else if (length >= 6 && strncmp(buffer,"wb_off",6)==0) {
        buffer += 7;
        length -= 7;
        printk("GDT: Disabling write back commands .. ");
        if (ha->cache_feat & GDT_WR_THROUGH) {
            gdth_write_through = TRUE;
            printk("Done.\n");
        } else {
            printk("Not supported !\n");
        }
        return(orig_length);
    } else if (length >= 5 && strncmp(buffer,"wb_on",5)==0) {
        buffer += 6;
        length -= 6;
        printk("GDT: Enabling write back commands .. ");
        gdth_write_through = FALSE;
        printk("Done.\n");
        return(orig_length);
    }

    if (wb_mode) {
	unsigned long flags;

	BUILD_BUG_ON(sizeof(gdth_cpar_str) > GDTH_SCRATCH);

	spin_lock_irqsave(&ha->smp_lock, flags);
	if (ha->scratch_busy) {
	    spin_unlock_irqrestore(&ha->smp_lock, flags);
            return -EBUSY;
	}
	ha->scratch_busy = TRUE;
	spin_unlock_irqrestore(&ha->smp_lock, flags);

        pcpar = (gdth_cpar_str *)ha->pscratch;
        memcpy( pcpar, &ha->cpar, sizeof(gdth_cpar_str) );
        gdtcmd.Service = CACHESERVICE;
        gdtcmd.OpCode = GDT_IOCTL;
        gdtcmd.u.ioctl.p_param = ha->scratch_phys;
        gdtcmd.u.ioctl.param_size = sizeof(gdth_cpar_str);
        gdtcmd.u.ioctl.subfunc = CACHE_CONFIG;
        gdtcmd.u.ioctl.channel = INVALID_CHANNEL;
        pcpar->write_back = wb_mode==1 ? 0:1;

        gdth_execute(host, &gdtcmd, cmnd, 30, NULL);

	spin_lock_irqsave(&ha->smp_lock, flags);
	ha->scratch_busy = FALSE;
	spin_unlock_irqrestore(&ha->smp_lock, flags);

        printk("Done.\n");
        return(orig_length);
    }

    printk("GDT: Unknown command: %s  Length: %d\n",buffer,length);
    return(-EINVAL);
}

int gdth_show_info(struct seq_file *m, struct Scsi_Host *host)
{
    gdth_ha_str *ha = shost_priv(host);
    int hlen;
    int id, i, j, k, sec, flag;
    int no_mdrv = 0, drv_no, is_mirr;
    u32 cnt;
    dma_addr_t paddr;
    int rc = -ENOMEM;

    gdth_cmd_str *gdtcmd;
    gdth_evt_str *estr;
    char hrec[277];

    char *buf;
    gdth_dskstat_str *pds;
    gdth_diskinfo_str *pdi;
    gdth_arrayinf_str *pai;
    gdth_defcnt_str *pdef;
    gdth_cdrinfo_str *pcdi;
    gdth_hget_str *phg;
    char cmnd[MAX_COMMAND_SIZE];

    gdtcmd = kmalloc(sizeof(*gdtcmd), GFP_KERNEL);
    estr = kmalloc(sizeof(*estr), GFP_KERNEL);
    if (!gdtcmd || !estr)
        goto free_fail;

    memset(cmnd, 0xff, 12);
    memset(gdtcmd, 0, sizeof(gdth_cmd_str));

    TRACE2(("gdth_get_info() ha %d\n",ha->hanum));

    
    /* request is i.e. "cat /proc/scsi/gdth/0" */ 
    /* format: %-15s\t%-10s\t%-15s\t%s */
    /* driver parameters */
    seq_puts(m, "Driver Parameters:\n");
    if (reserve_list[0] == 0xff)
        strcpy(hrec, "--");
    else {
        hlen = sprintf(hrec, "%d", reserve_list[0]);
        for (i = 1;  i < MAX_RES_ARGS; i++) {
            if (reserve_list[i] == 0xff) 
                break;
            hlen += snprintf(hrec + hlen , 161 - hlen, ",%d", reserve_list[i]);
        }
    }
    seq_printf(m,
                   " reserve_mode: \t%d         \treserve_list:  \t%s\n",
                   reserve_mode, hrec);
    seq_printf(m,
                   " max_ids:      \t%-3d       \thdr_channel:   \t%d\n",
                   max_ids, hdr_channel);

    /* controller information */
    seq_puts(m, "\nDisk Array Controller Information:\n");
    seq_printf(m,
                   " Number:       \t%d         \tName:          \t%s\n",
                   ha->hanum, ha->binfo.type_string);

    seq_printf(m,
                   " Driver Ver.:  \t%-10s\tFirmware Ver.: \t",
                   GDTH_VERSION_STR);
    if (ha->more_proc)
        seq_printf(m, "%d.%02d.%02d-%c%03X\n", 
                (u8)(ha->binfo.upd_fw_ver>>24),
                (u8)(ha->binfo.upd_fw_ver>>16),
                (u8)(ha->binfo.upd_fw_ver),
                ha->bfeat.raid ? 'R':'N',
                ha->binfo.upd_revision);
    else
        seq_printf(m, "%d.%02d\n", (u8)(ha->cpar.version>>8),
                (u8)(ha->cpar.version));
 
    if (ha->more_proc)
        /* more information: 1. about controller */
        seq_printf(m,
                       " Serial No.:   \t0x%8X\tCache RAM size:\t%d KB\n",
                       ha->binfo.ser_no, ha->binfo.memsize / 1024);

    if (ha->more_proc) {
        size_t size = max_t(size_t, GDTH_SCRATCH, sizeof(gdth_hget_str));

        /* more information: 2. about physical devices */
        seq_puts(m, "\nPhysical Devices:");
        flag = FALSE;
            
        buf = dma_alloc_coherent(&ha->pdev->dev, size, &paddr, GFP_KERNEL);
        if (!buf) 
            goto stop_output;
        for (i = 0; i < ha->bus_cnt; ++i) {
            /* 2.a statistics (and retries/reassigns) */
            TRACE2(("pdr_statistics() chn %d\n",i));                
            pds = (gdth_dskstat_str *)(buf + GDTH_SCRATCH/4);
            gdtcmd->Service = CACHESERVICE;
            gdtcmd->OpCode = GDT_IOCTL;
            gdtcmd->u.ioctl.p_param = paddr + GDTH_SCRATCH/4;
            gdtcmd->u.ioctl.param_size = 3*GDTH_SCRATCH/4;
            gdtcmd->u.ioctl.subfunc = DSK_STATISTICS | L_CTRL_PATTERN;
            gdtcmd->u.ioctl.channel = ha->raw[i].address | INVALID_CHANNEL;
            pds->bid = ha->raw[i].local_no;
            pds->first = 0;
            pds->entries = ha->raw[i].pdev_cnt;
            cnt = (3*GDTH_SCRATCH/4 - 5 * sizeof(u32)) /
                sizeof(pds->list[0]);
            if (pds->entries > cnt)
                pds->entries = cnt;

            if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) != S_OK)
                pds->count = 0;

            /* other IOCTLs must fit into area GDTH_SCRATCH/4 */
            for (j = 0; j < ha->raw[i].pdev_cnt; ++j) {
                /* 2.b drive info */
                TRACE2(("scsi_drv_info() chn %d dev %d\n",
                    i, ha->raw[i].id_list[j]));             
                pdi = (gdth_diskinfo_str *)buf;
                gdtcmd->Service = CACHESERVICE;
                gdtcmd->OpCode = GDT_IOCTL;
                gdtcmd->u.ioctl.p_param = paddr;
                gdtcmd->u.ioctl.param_size = sizeof(gdth_diskinfo_str);
                gdtcmd->u.ioctl.subfunc = SCSI_DR_INFO | L_CTRL_PATTERN;
                gdtcmd->u.ioctl.channel = 
                    ha->raw[i].address | ha->raw[i].id_list[j];

                if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) == S_OK) {
                    strncpy(hrec,pdi->vendor,8);
                    strncpy(hrec+8,pdi->product,16);
                    strncpy(hrec+24,pdi->revision,4);
                    hrec[28] = 0;
                    seq_printf(m,
                                   "\n Chn/ID/LUN:   \t%c/%02d/%d    \tName:          \t%s\n",
                                   'A'+i,pdi->target_id,pdi->lun,hrec);
                    flag = TRUE;
                    pdi->no_ldrive &= 0xffff;
                    if (pdi->no_ldrive == 0xffff)
                        strcpy(hrec,"--");
                    else
                        sprintf(hrec,"%d",pdi->no_ldrive);
                    seq_printf(m,
                                   " Capacity [MB]:\t%-6d    \tTo Log. Drive: \t%s\n",
                                   pdi->blkcnt/(1024*1024/pdi->blksize),
                                   hrec);
                } else {
                    pdi->devtype = 0xff;
                }
                    
                if (pdi->devtype == 0) {
                    /* search retries/reassigns */
                    for (k = 0; k < pds->count; ++k) {
                        if (pds->list[k].tid == pdi->target_id &&
                            pds->list[k].lun == pdi->lun) {
                            seq_printf(m,
                                           " Retries:      \t%-6d    \tReassigns:     \t%d\n",
                                           pds->list[k].retries,
                                           pds->list[k].reassigns);
                            break;
                        }
                    }
                    /* 2.c grown defects */
                    TRACE2(("scsi_drv_defcnt() chn %d dev %d\n",
                            i, ha->raw[i].id_list[j]));             
                    pdef = (gdth_defcnt_str *)buf;
                    gdtcmd->Service = CACHESERVICE;
                    gdtcmd->OpCode = GDT_IOCTL;
                    gdtcmd->u.ioctl.p_param = paddr;
                    gdtcmd->u.ioctl.param_size = sizeof(gdth_defcnt_str);
                    gdtcmd->u.ioctl.subfunc = SCSI_DEF_CNT | L_CTRL_PATTERN;
                    gdtcmd->u.ioctl.channel = 
                        ha->raw[i].address | ha->raw[i].id_list[j];
                    pdef->sddc_type = 0x08;

                    if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) == S_OK) {
                        seq_printf(m,
                                       " Grown Defects:\t%d\n",
                                       pdef->sddc_cnt);
                    }
                }
            }
        }

        if (!flag)
            seq_puts(m, "\n --\n");

        /* 3. about logical drives */
        seq_puts(m, "\nLogical Drives:");
        flag = FALSE;

        for (i = 0; i < MAX_LDRIVES; ++i) {
            if (!ha->hdr[i].is_logdrv)
                continue;
            drv_no = i;
            j = k = 0;
            is_mirr = FALSE;
            do {
                /* 3.a log. drive info */
                TRACE2(("cache_drv_info() drive no %d\n",drv_no));
                pcdi = (gdth_cdrinfo_str *)buf;
                gdtcmd->Service = CACHESERVICE;
                gdtcmd->OpCode = GDT_IOCTL;
                gdtcmd->u.ioctl.p_param = paddr;
                gdtcmd->u.ioctl.param_size = sizeof(gdth_cdrinfo_str);
                gdtcmd->u.ioctl.subfunc = CACHE_DRV_INFO;
                gdtcmd->u.ioctl.channel = drv_no;
                if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) != S_OK)
                    break;
                pcdi->ld_dtype >>= 16;
                j++;
                if (pcdi->ld_dtype > 2) {
                    strcpy(hrec, "missing");
                } else if (pcdi->ld_error & 1) {
                    strcpy(hrec, "fault");
                } else if (pcdi->ld_error & 2) {
                    strcpy(hrec, "invalid");
                    k++; j--;
                } else {
                    strcpy(hrec, "ok");
                }
                    
                if (drv_no == i) {
                    seq_printf(m,
                                   "\n Number:       \t%-2d        \tStatus:        \t%s\n",
                                   drv_no, hrec);
                    flag = TRUE;
                    no_mdrv = pcdi->cd_ldcnt;
                    if (no_mdrv > 1 || pcdi->ld_slave != -1) {
                        is_mirr = TRUE;
                        strcpy(hrec, "RAID-1");
                    } else if (pcdi->ld_dtype == 0) {
                        strcpy(hrec, "Disk");
                    } else if (pcdi->ld_dtype == 1) {
                        strcpy(hrec, "RAID-0");
                    } else if (pcdi->ld_dtype == 2) {
                        strcpy(hrec, "Chain");
                    } else {
                        strcpy(hrec, "???");
                    }
                    seq_printf(m,
                                   " Capacity [MB]:\t%-6d    \tType:          \t%s\n",
                                   pcdi->ld_blkcnt/(1024*1024/pcdi->ld_blksize),
                                   hrec);
                } else {
                    seq_printf(m,
                                   " Slave Number: \t%-2d        \tStatus:        \t%s\n",
                                   drv_no & 0x7fff, hrec);
                }
                drv_no = pcdi->ld_slave;
            } while (drv_no != -1);
             
            if (is_mirr)
                seq_printf(m,
                               " Missing Drv.: \t%-2d        \tInvalid Drv.:  \t%d\n",
                               no_mdrv - j - k, k);

            if (!ha->hdr[i].is_arraydrv)
                strcpy(hrec, "--");
            else
                sprintf(hrec, "%d", ha->hdr[i].master_no);
            seq_printf(m,
                           " To Array Drv.:\t%s\n", hrec);
        }       

        if (!flag)
            seq_puts(m, "\n --\n");

        /* 4. about array drives */
        seq_puts(m, "\nArray Drives:");
        flag = FALSE;

        for (i = 0; i < MAX_LDRIVES; ++i) {
            if (!(ha->hdr[i].is_arraydrv && ha->hdr[i].is_master))
                continue;
            /* 4.a array drive info */
            TRACE2(("array_info() drive no %d\n",i));
            pai = (gdth_arrayinf_str *)buf;
            gdtcmd->Service = CACHESERVICE;
            gdtcmd->OpCode = GDT_IOCTL;
            gdtcmd->u.ioctl.p_param = paddr;
            gdtcmd->u.ioctl.param_size = sizeof(gdth_arrayinf_str);
            gdtcmd->u.ioctl.subfunc = ARRAY_INFO | LA_CTRL_PATTERN;
            gdtcmd->u.ioctl.channel = i;
            if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) == S_OK) {
                if (pai->ai_state == 0)
                    strcpy(hrec, "idle");
                else if (pai->ai_state == 2)
                    strcpy(hrec, "build");
                else if (pai->ai_state == 4)
                    strcpy(hrec, "ready");
                else if (pai->ai_state == 6)
                    strcpy(hrec, "fail");
                else if (pai->ai_state == 8 || pai->ai_state == 10)
                    strcpy(hrec, "rebuild");
                else
                    strcpy(hrec, "error");
                if (pai->ai_ext_state & 0x10)
                    strcat(hrec, "/expand");
                else if (pai->ai_ext_state & 0x1)
                    strcat(hrec, "/patch");
                seq_printf(m,
                               "\n Number:       \t%-2d        \tStatus:        \t%s\n",
                               i,hrec);
                flag = TRUE;

                if (pai->ai_type == 0)
                    strcpy(hrec, "RAID-0");
                else if (pai->ai_type == 4)
                    strcpy(hrec, "RAID-4");
                else if (pai->ai_type == 5)
                    strcpy(hrec, "RAID-5");
                else 
                    strcpy(hrec, "RAID-10");
                seq_printf(m,
                               " Capacity [MB]:\t%-6d    \tType:          \t%s\n",
                               pai->ai_size/(1024*1024/pai->ai_secsize),
                               hrec);
            }
        }

        if (!flag)
            seq_puts(m, "\n --\n");

        /* 5. about host drives */
        seq_puts(m, "\nHost Drives:");
        flag = FALSE;

        for (i = 0; i < MAX_LDRIVES; ++i) {
            if (!ha->hdr[i].is_logdrv || 
                (ha->hdr[i].is_arraydrv && !ha->hdr[i].is_master))
                continue;
            /* 5.a get host drive list */
            TRACE2(("host_get() drv_no %d\n",i));           
            phg = (gdth_hget_str *)buf;
            gdtcmd->Service = CACHESERVICE;
            gdtcmd->OpCode = GDT_IOCTL;
            gdtcmd->u.ioctl.p_param = paddr;
            gdtcmd->u.ioctl.param_size = sizeof(gdth_hget_str);
            gdtcmd->u.ioctl.subfunc = HOST_GET | LA_CTRL_PATTERN;
            gdtcmd->u.ioctl.channel = i;
            phg->entries = MAX_HDRIVES;
            phg->offset = GDTOFFSOF(gdth_hget_str, entry[0]); 
            if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) == S_OK) {
                ha->hdr[i].ldr_no = i;
                ha->hdr[i].rw_attribs = 0;
                ha->hdr[i].start_sec = 0;
            } else {
                for (j = 0; j < phg->entries; ++j) {
                    k = phg->entry[j].host_drive;
                    if (k >= MAX_LDRIVES)
                        continue;
                    ha->hdr[k].ldr_no = phg->entry[j].log_drive;
                    ha->hdr[k].rw_attribs = phg->entry[j].rw_attribs;
                    ha->hdr[k].start_sec = phg->entry[j].start_sec;
                }
            }
        }
	dma_free_coherent(&ha->pdev->dev, size, buf, paddr);

        for (i = 0; i < MAX_HDRIVES; ++i) {
            if (!(ha->hdr[i].present))
                continue;
              
            seq_printf(m,
                           "\n Number:       \t%-2d        \tArr/Log. Drive:\t%d\n",
                           i, ha->hdr[i].ldr_no);
            flag = TRUE;

            seq_printf(m,
                           " Capacity [MB]:\t%-6d    \tStart Sector:  \t%d\n",
                           (u32)(ha->hdr[i].size/2048), ha->hdr[i].start_sec);
        }
        
        if (!flag)
            seq_puts(m, "\n --\n");
    }

    /* controller events */
    seq_puts(m, "\nController Events:\n");

    for (id = -1;;) {
        id = gdth_read_event(ha, id, estr);
        if (estr->event_source == 0)
            break;
        if (estr->event_data.eu.driver.ionode == ha->hanum &&
            estr->event_source == ES_ASYNC) { 
            gdth_log_event(&estr->event_data, hrec);

	    /*
	     * Elapsed seconds subtraction with unsigned operands is
	     * safe from wrap around in year 2106.  Executes as:
	     * operand a + (2's complement operand b) + 1
	     */

	    sec = (int)((u32)ktime_get_real_seconds() - estr->first_stamp);
            if (sec < 0) sec = 0;
            seq_printf(m," date- %02d:%02d:%02d\t%s\n",
                           sec/3600, sec%3600/60, sec%60, hrec);
        }
        if (id == -1)
            break;
    }
stop_output:
    rc = 0;
free_fail:
    kfree(gdtcmd);
    kfree(estr);
    return rc;
}

static void gdth_wait_completion(gdth_ha_str *ha, int busnum, int id)
{
    unsigned long flags;
    int i;
    struct scsi_cmnd *scp;
    struct gdth_cmndinfo *cmndinfo;
    u8 b, t;

    spin_lock_irqsave(&ha->smp_lock, flags);

    for (i = 0; i < GDTH_MAXCMDS; ++i) {
        scp = ha->cmd_tab[i].cmnd;
        cmndinfo = gdth_cmnd_priv(scp);

        b = scp->device->channel;
        t = scp->device->id;
        if (!SPECIAL_SCP(scp) && t == (u8)id && 
            b == (u8)busnum) {
            cmndinfo->wait_for_completion = 0;
            spin_unlock_irqrestore(&ha->smp_lock, flags);
            while (!cmndinfo->wait_for_completion)
                barrier();
            spin_lock_irqsave(&ha->smp_lock, flags);
        }
    }
    spin_unlock_irqrestore(&ha->smp_lock, flags);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4	2	/* gdth_proc.c
cbd5f69b	3	* $Id: gdth_proc.c,v 1.43 2006/01/11 16:15:00 achim Exp $
1da177e4 LT	4	*/
	5
	6	#include <linux/completion.h>
5a0e3ad6	7	#include <linux/slab.h>
1da177e4	8
3e0552ee	9	int gdth_set_info(struct Scsi_Host host, char buffer, int length)
1da177e4	10	{
45f1a41b	11	gdth_ha_str *ha = shost_priv(host);
cbd5f69b	12	int ret_val = -EINVAL;
1da177e4	13
45f1a41b	14	TRACE2(("gdth_set_info() ha %d\n",ha->hanum,));
1da177e4 LT	15
	16	if (length >= 4) {
	17	if (strncmp(buffer,"gdth",4) == 0) {
	18	buffer += 5;
	19	length -= 5;
45f1a41b	20	ret_val = gdth_set_asc_info(host, buffer, length, ha);
1da177e4 LT	21	}
1da177e4 LT	22	}
cbd5f69b	23
1da177e4 LT	24	return ret_val;
	25	}
	26
cbd5f69b	27	static int gdth_set_asc_info(struct Scsi_Host host, char buffer,
45f1a41b	28	int length, gdth_ha_str *ha)
1da177e4	29	{
cbd5f69b LA	30	int orig_length, drive, wb_mode;
cbd5f69b LA	31	int i, found;
1da177e4 LT	32	gdth_cmd_str gdtcmd;
1da177e4 LT	33	gdth_cpar_str *pcpar;
1da177e4 LT	34
	35	char cmnd[MAX_COMMAND_SIZE];
	36	memset(cmnd, 0xff, 12);
	37	memset(&gdtcmd, 0, sizeof(gdth_cmd_str));
	38
45f1a41b	39	TRACE2(("gdth_set_asc_info() ha %d\n",ha->hanum));
1da177e4 LT	40	orig_length = length + 5;
	41	drive = -1;
	42	wb_mode = 0;
	43	found = FALSE;
	44
	45	if (length >= 5 && strncmp(buffer,"flush",5)==0) {
	46	buffer += 6;
	47	length -= 6;
	48	if (length && buffer>='0' && buffer<='9') {
	49	drive = (int)(*buffer-'0');
	50	++buffer; --length;
	51	if (length && buffer>='0' && buffer<='9') {
	52	drive = drive10 + (int)(buffer-'0');
	53	++buffer; --length;
	54	}
	55	printk("GDT: Flushing host drive %d .. ",drive);
	56	} else {
	57	printk("GDT: Flushing all host drives .. ");
	58	}
	59	for (i = 0; i < MAX_HDRIVES; ++i) {
	60	if (ha->hdr[i].present) {
	61	if (drive != -1 && i != drive)
	62	continue;
	63	found = TRUE;
	64	gdtcmd.Service = CACHESERVICE;
	65	gdtcmd.OpCode = GDT_FLUSH;
	66	if (ha->cache_feat & GDT_64BIT) {
	67	gdtcmd.u.cache64.DeviceNo = i;
	68	gdtcmd.u.cache64.BlockNo = 1;
	69	} else {
	70	gdtcmd.u.cache.DeviceNo = i;
	71	gdtcmd.u.cache.BlockNo = 1;
	72	}
cbd5f69b LA	73
cbd5f69b LA	74	gdth_execute(host, &gdtcmd, cmnd, 30, NULL);
1da177e4 LT	75	}
	76	}
	77	if (!found)
	78	printk("\nNo host drive found !\n");
	79	else
	80	printk("Done.\n");
	81	return(orig_length);
	82	}
	83
	84	if (length >= 7 && strncmp(buffer,"wbp_off",7)==0) {
	85	buffer += 8;
	86	length -= 8;
	87	printk("GDT: Disabling write back permanently .. ");
	88	wb_mode = 1;
	89	} else if (length >= 6 && strncmp(buffer,"wbp_on",6)==0) {
	90	buffer += 7;
	91	length -= 7;
	92	printk("GDT: Enabling write back permanently .. ");
	93	wb_mode = 2;
	94	} else if (length >= 6 && strncmp(buffer,"wb_off",6)==0) {
	95	buffer += 7;
	96	length -= 7;
	97	printk("GDT: Disabling write back commands .. ");
	98	if (ha->cache_feat & GDT_WR_THROUGH) {
	99	gdth_write_through = TRUE;
	100	printk("Done.\n");
	101	} else {
	102	printk("Not supported !\n");
	103	}
	104	return(orig_length);
	105	} else if (length >= 5 && strncmp(buffer,"wb_on",5)==0) {
	106	buffer += 6;
	107	length -= 6;
	108	printk("GDT: Enabling write back commands .. ");
	109	gdth_write_through = FALSE;
	110	printk("Done.\n");
	111	return(orig_length);
	112	}
	113
	114	if (wb_mode) {
463563fa CH	115	unsigned long flags;
	116
	117	BUILD_BUG_ON(sizeof(gdth_cpar_str) > GDTH_SCRATCH);
	118
	119	spin_lock_irqsave(&ha->smp_lock, flags);
	120	if (ha->scratch_busy) {
	121	spin_unlock_irqrestore(&ha->smp_lock, flags);
	122	return -EBUSY;
	123	}
	124	ha->scratch_busy = TRUE;
	125	spin_unlock_irqrestore(&ha->smp_lock, flags);
	126
1da177e4 LT	127	pcpar = (gdth_cpar_str *)ha->pscratch;
	128	memcpy( pcpar, &ha->cpar, sizeof(gdth_cpar_str) );
	129	gdtcmd.Service = CACHESERVICE;
	130	gdtcmd.OpCode = GDT_IOCTL;
463563fa	131	gdtcmd.u.ioctl.p_param = ha->scratch_phys;
1da177e4 LT	132	gdtcmd.u.ioctl.param_size = sizeof(gdth_cpar_str);
	133	gdtcmd.u.ioctl.subfunc = CACHE_CONFIG;
	134	gdtcmd.u.ioctl.channel = INVALID_CHANNEL;
	135	pcpar->write_back = wb_mode==1 ? 0:1;
cbd5f69b LA	136
	137	gdth_execute(host, &gdtcmd, cmnd, 30, NULL);
	138
463563fa CH	139	spin_lock_irqsave(&ha->smp_lock, flags);
	140	ha->scratch_busy = FALSE;
	141	spin_unlock_irqrestore(&ha->smp_lock, flags);
	142
1da177e4 LT	143	printk("Done.\n");
	144	return(orig_length);
	145	}
	146
	147	printk("GDT: Unknown command: %s Length: %d\n",buffer,length);
	148	return(-EINVAL);
	149	}
	150
3e0552ee	151	int gdth_show_info(struct seq_file m, struct Scsi_Host host)
1da177e4	152	{
3e0552ee	153	gdth_ha_str *ha = shost_priv(host);
238ddbb9	154	int hlen;
1da177e4 LT	155	int id, i, j, k, sec, flag;
1da177e4 LT	156	int no_mdrv = 0, drv_no, is_mirr;
1fe6dbf4	157	u32 cnt;
463563fa	158	dma_addr_t paddr;
1da177e4 LT	159	int rc = -ENOMEM;
	160
	161	gdth_cmd_str *gdtcmd;
	162	gdth_evt_str *estr;
345ebae7	163	char hrec[277];
1da177e4 LT	164
	165	char *buf;
	166	gdth_dskstat_str *pds;
	167	gdth_diskinfo_str *pdi;
	168	gdth_arrayinf_str *pai;
	169	gdth_defcnt_str *pdef;
	170	gdth_cdrinfo_str *pcdi;
	171	gdth_hget_str *phg;
	172	char cmnd[MAX_COMMAND_SIZE];
	173
	174	gdtcmd = kmalloc(sizeof(*gdtcmd), GFP_KERNEL);
	175	estr = kmalloc(sizeof(*estr), GFP_KERNEL);
	176	if (!gdtcmd \|\| !estr)
cbd5f69b	177	goto free_fail;
1da177e4 LT	178
	179	memset(cmnd, 0xff, 12);
	180	memset(gdtcmd, 0, sizeof(gdth_cmd_str));
	181
45f1a41b	182	TRACE2(("gdth_get_info() ha %d\n",ha->hanum));
1da177e4	183
1da177e4 LT	184
	185	/* request is i.e. "cat /proc/scsi/gdth/0" */
	186	/* format: %-15s\t%-10s\t%-15s\t%s */
	187	/* driver parameters */
91c40f24	188	seq_puts(m, "Driver Parameters:\n");
1da177e4 LT	189	if (reserve_list[0] == 0xff)
	190	strcpy(hrec, "--");
	191	else {
238ddbb9	192	hlen = sprintf(hrec, "%d", reserve_list[0]);
1da177e4 LT	193	for (i = 1; i < MAX_RES_ARGS; i++) {
	194	if (reserve_list[i] == 0xff)
	195	break;
238ddbb9	196	hlen += snprintf(hrec + hlen , 161 - hlen, ",%d", reserve_list[i]);
1da177e4 LT	197	}
1da177e4 LT	198	}
3e0552ee	199	seq_printf(m,
1da177e4 LT	200	" reserve_mode: \t%d \treserve_list: \t%s\n",
1da177e4 LT	201	reserve_mode, hrec);
3e0552ee	202	seq_printf(m,
1da177e4 LT	203	" max_ids: \t%-3d \thdr_channel: \t%d\n",
1da177e4 LT	204	max_ids, hdr_channel);
1da177e4 LT	205
1da177e4 LT	206	/* controller information */
91c40f24	207	seq_puts(m, "\nDisk Array Controller Information:\n");
3e0552ee	208	seq_printf(m,
1da177e4	209	" Number: \t%d \tName: \t%s\n",
3e0552ee	210	ha->hanum, ha->binfo.type_string);
1da177e4	211
3e0552ee AV	212	seq_printf(m,
	213	" Driver Ver.: \t%-10s\tFirmware Ver.: \t",
	214	GDTH_VERSION_STR);
1da177e4	215	if (ha->more_proc)
3e0552ee	216	seq_printf(m, "%d.%02d.%02d-%c%03X\n",
1fe6dbf4 DJ	217	(u8)(ha->binfo.upd_fw_ver>>24),
	218	(u8)(ha->binfo.upd_fw_ver>>16),
	219	(u8)(ha->binfo.upd_fw_ver),
1da177e4 LT	220	ha->bfeat.raid ? 'R':'N',
	221	ha->binfo.upd_revision);
	222	else
3e0552ee	223	seq_printf(m, "%d.%02d\n", (u8)(ha->cpar.version>>8),
1fe6dbf4	224	(u8)(ha->cpar.version));
1da177e4	225
3e0552ee	226	if (ha->more_proc)
1da177e4	227	/* more information: 1. about controller */
3e0552ee	228	seq_printf(m,
1da177e4 LT	229	" Serial No.: \t0x%8X\tCache RAM size:\t%d KB\n",
1da177e4 LT	230	ha->binfo.ser_no, ha->binfo.memsize / 1024);
1da177e4	231
1da177e4	232	if (ha->more_proc) {
8d22022c CH	233	size_t size = max_t(size_t, GDTH_SCRATCH, sizeof(gdth_hget_str));
8d22022c CH	234
1da177e4	235	/* more information: 2. about physical devices */
91c40f24	236	seq_puts(m, "\nPhysical Devices:");
1da177e4 LT	237	flag = FALSE;
1da177e4 LT	238
bb327df8	239	buf = dma_alloc_coherent(&ha->pdev->dev, size, &paddr, GFP_KERNEL);
1da177e4 LT	240	if (!buf)
	241	goto stop_output;
	242	for (i = 0; i < ha->bus_cnt; ++i) {
	243	/* 2.a statistics (and retries/reassigns) */
	244	TRACE2(("pdr_statistics() chn %d\n",i));
	245	pds = (gdth_dskstat_str *)(buf + GDTH_SCRATCH/4);
	246	gdtcmd->Service = CACHESERVICE;
	247	gdtcmd->OpCode = GDT_IOCTL;
	248	gdtcmd->u.ioctl.p_param = paddr + GDTH_SCRATCH/4;
	249	gdtcmd->u.ioctl.param_size = 3*GDTH_SCRATCH/4;
	250	gdtcmd->u.ioctl.subfunc = DSK_STATISTICS \| L_CTRL_PATTERN;
	251	gdtcmd->u.ioctl.channel = ha->raw[i].address \| INVALID_CHANNEL;
	252	pds->bid = ha->raw[i].local_no;
	253	pds->first = 0;
	254	pds->entries = ha->raw[i].pdev_cnt;
1fe6dbf4	255	cnt = (3GDTH_SCRATCH/4 - 5 sizeof(u32)) /
1da177e4 LT	256	sizeof(pds->list[0]);
	257	if (pds->entries > cnt)
	258	pds->entries = cnt;
cbd5f69b LA	259
cbd5f69b LA	260	if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) != S_OK)
1da177e4	261	pds->count = 0;
1da177e4 LT	262
	263	/* other IOCTLs must fit into area GDTH_SCRATCH/4 */
	264	for (j = 0; j < ha->raw[i].pdev_cnt; ++j) {
	265	/* 2.b drive info */
	266	TRACE2(("scsi_drv_info() chn %d dev %d\n",
	267	i, ha->raw[i].id_list[j]));
	268	pdi = (gdth_diskinfo_str *)buf;
	269	gdtcmd->Service = CACHESERVICE;
	270	gdtcmd->OpCode = GDT_IOCTL;
	271	gdtcmd->u.ioctl.p_param = paddr;
	272	gdtcmd->u.ioctl.param_size = sizeof(gdth_diskinfo_str);
	273	gdtcmd->u.ioctl.subfunc = SCSI_DR_INFO \| L_CTRL_PATTERN;
	274	gdtcmd->u.ioctl.channel =
	275	ha->raw[i].address \| ha->raw[i].id_list[j];
cbd5f69b LA	276
cbd5f69b LA	277	if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) == S_OK) {
1da177e4 LT	278	strncpy(hrec,pdi->vendor,8);
	279	strncpy(hrec+8,pdi->product,16);
	280	strncpy(hrec+24,pdi->revision,4);
	281	hrec[28] = 0;
3e0552ee	282	seq_printf(m,
1da177e4 LT	283	"\n Chn/ID/LUN: \t%c/%02d/%d \tName: \t%s\n",
1da177e4 LT	284	'A'+i,pdi->target_id,pdi->lun,hrec);
1da177e4 LT	285	flag = TRUE;
	286	pdi->no_ldrive &= 0xffff;
	287	if (pdi->no_ldrive == 0xffff)
	288	strcpy(hrec,"--");
	289	else
	290	sprintf(hrec,"%d",pdi->no_ldrive);
3e0552ee	291	seq_printf(m,
1da177e4 LT	292	" Capacity [MB]:\t%-6d \tTo Log. Drive: \t%s\n",
	293	pdi->blkcnt/(1024*1024/pdi->blksize),
	294	hrec);
1da177e4 LT	295	} else {
	296	pdi->devtype = 0xff;
	297	}
	298
	299	if (pdi->devtype == 0) {
	300	/* search retries/reassigns */
	301	for (k = 0; k < pds->count; ++k) {
	302	if (pds->list[k].tid == pdi->target_id &&
	303	pds->list[k].lun == pdi->lun) {
3e0552ee	304	seq_printf(m,
1da177e4 LT	305	" Retries: \t%-6d \tReassigns: \t%d\n",
	306	pds->list[k].retries,
	307	pds->list[k].reassigns);
1da177e4 LT	308	break;
	309	}
	310	}
	311	/* 2.c grown defects */
	312	TRACE2(("scsi_drv_defcnt() chn %d dev %d\n",
	313	i, ha->raw[i].id_list[j]));
	314	pdef = (gdth_defcnt_str *)buf;
	315	gdtcmd->Service = CACHESERVICE;
	316	gdtcmd->OpCode = GDT_IOCTL;
	317	gdtcmd->u.ioctl.p_param = paddr;
	318	gdtcmd->u.ioctl.param_size = sizeof(gdth_defcnt_str);
	319	gdtcmd->u.ioctl.subfunc = SCSI_DEF_CNT \| L_CTRL_PATTERN;
	320	gdtcmd->u.ioctl.channel =
	321	ha->raw[i].address \| ha->raw[i].id_list[j];
	322	pdef->sddc_type = 0x08;
cbd5f69b LA	323
cbd5f69b LA	324	if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) == S_OK) {
3e0552ee	325	seq_printf(m,
1da177e4 LT	326	" Grown Defects:\t%d\n",
1da177e4 LT	327	pdef->sddc_cnt);
1da177e4 LT	328	}
1da177e4 LT	329	}
1da177e4 LT	330	}
1da177e4 LT	331	}
1da177e4	332
3e0552ee	333	if (!flag)
91c40f24	334	seq_puts(m, "\n --\n");
1da177e4 LT	335
1da177e4 LT	336	/* 3. about logical drives */
91c40f24	337	seq_puts(m, "\nLogical Drives:");
1da177e4 LT	338	flag = FALSE;
1da177e4 LT	339
1da177e4 LT	340	for (i = 0; i < MAX_LDRIVES; ++i) {
	341	if (!ha->hdr[i].is_logdrv)
	342	continue;
	343	drv_no = i;
	344	j = k = 0;
	345	is_mirr = FALSE;
	346	do {
	347	/* 3.a log. drive info */
	348	TRACE2(("cache_drv_info() drive no %d\n",drv_no));
	349	pcdi = (gdth_cdrinfo_str *)buf;
	350	gdtcmd->Service = CACHESERVICE;
	351	gdtcmd->OpCode = GDT_IOCTL;
	352	gdtcmd->u.ioctl.p_param = paddr;
	353	gdtcmd->u.ioctl.param_size = sizeof(gdth_cdrinfo_str);
	354	gdtcmd->u.ioctl.subfunc = CACHE_DRV_INFO;
	355	gdtcmd->u.ioctl.channel = drv_no;
cbd5f69b	356	if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) != S_OK)
1da177e4	357	break;
1da177e4 LT	358	pcdi->ld_dtype >>= 16;
	359	j++;
	360	if (pcdi->ld_dtype > 2) {
	361	strcpy(hrec, "missing");
	362	} else if (pcdi->ld_error & 1) {
	363	strcpy(hrec, "fault");
	364	} else if (pcdi->ld_error & 2) {
	365	strcpy(hrec, "invalid");
	366	k++; j--;
	367	} else {
	368	strcpy(hrec, "ok");
	369	}
	370
	371	if (drv_no == i) {
3e0552ee	372	seq_printf(m,
1da177e4 LT	373	"\n Number: \t%-2d \tStatus: \t%s\n",
1da177e4 LT	374	drv_no, hrec);
1da177e4 LT	375	flag = TRUE;
	376	no_mdrv = pcdi->cd_ldcnt;
	377	if (no_mdrv > 1 \|\| pcdi->ld_slave != -1) {
	378	is_mirr = TRUE;
	379	strcpy(hrec, "RAID-1");
	380	} else if (pcdi->ld_dtype == 0) {
	381	strcpy(hrec, "Disk");
	382	} else if (pcdi->ld_dtype == 1) {
	383	strcpy(hrec, "RAID-0");
	384	} else if (pcdi->ld_dtype == 2) {
	385	strcpy(hrec, "Chain");
	386	} else {
	387	strcpy(hrec, "???");
	388	}
3e0552ee	389	seq_printf(m,
1da177e4 LT	390	" Capacity [MB]:\t%-6d \tType: \t%s\n",
	391	pcdi->ld_blkcnt/(1024*1024/pcdi->ld_blksize),
	392	hrec);
1da177e4	393	} else {
3e0552ee	394	seq_printf(m,
1da177e4 LT	395	" Slave Number: \t%-2d \tStatus: \t%s\n",
1da177e4 LT	396	drv_no & 0x7fff, hrec);
1da177e4 LT	397	}
1da177e4 LT	398	drv_no = pcdi->ld_slave;
1da177e4 LT	399	} while (drv_no != -1);
1da177e4 LT	400
3e0552ee AV	401	if (is_mirr)
3e0552ee AV	402	seq_printf(m,
1da177e4 LT	403	" Missing Drv.: \t%-2d \tInvalid Drv.: \t%d\n",
1da177e4 LT	404	no_mdrv - j - k, k);
3e0552ee	405
1da177e4 LT	406	if (!ha->hdr[i].is_arraydrv)
	407	strcpy(hrec, "--");
	408	else
	409	sprintf(hrec, "%d", ha->hdr[i].master_no);
3e0552ee	410	seq_printf(m,
1da177e4	411	" To Array Drv.:\t%s\n", hrec);
1da177e4	412	}
463563fa	413
3e0552ee	414	if (!flag)
91c40f24	415	seq_puts(m, "\n --\n");
1da177e4 LT	416
1da177e4 LT	417	/* 4. about array drives */
91c40f24	418	seq_puts(m, "\nArray Drives:");
1da177e4 LT	419	flag = FALSE;
1da177e4 LT	420
1da177e4 LT	421	for (i = 0; i < MAX_LDRIVES; ++i) {
	422	if (!(ha->hdr[i].is_arraydrv && ha->hdr[i].is_master))
	423	continue;
	424	/* 4.a array drive info */
	425	TRACE2(("array_info() drive no %d\n",i));
	426	pai = (gdth_arrayinf_str *)buf;
	427	gdtcmd->Service = CACHESERVICE;
	428	gdtcmd->OpCode = GDT_IOCTL;
	429	gdtcmd->u.ioctl.p_param = paddr;
	430	gdtcmd->u.ioctl.param_size = sizeof(gdth_arrayinf_str);
	431	gdtcmd->u.ioctl.subfunc = ARRAY_INFO \| LA_CTRL_PATTERN;
	432	gdtcmd->u.ioctl.channel = i;
cbd5f69b	433	if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) == S_OK) {
1da177e4 LT	434	if (pai->ai_state == 0)
	435	strcpy(hrec, "idle");
	436	else if (pai->ai_state == 2)
	437	strcpy(hrec, "build");
	438	else if (pai->ai_state == 4)
	439	strcpy(hrec, "ready");
	440	else if (pai->ai_state == 6)
	441	strcpy(hrec, "fail");
	442	else if (pai->ai_state == 8 \|\| pai->ai_state == 10)
	443	strcpy(hrec, "rebuild");
	444	else
	445	strcpy(hrec, "error");
	446	if (pai->ai_ext_state & 0x10)
	447	strcat(hrec, "/expand");
	448	else if (pai->ai_ext_state & 0x1)
	449	strcat(hrec, "/patch");
3e0552ee	450	seq_printf(m,
1da177e4 LT	451	"\n Number: \t%-2d \tStatus: \t%s\n",
1da177e4 LT	452	i,hrec);
1da177e4 LT	453	flag = TRUE;
	454
	455	if (pai->ai_type == 0)
	456	strcpy(hrec, "RAID-0");
	457	else if (pai->ai_type == 4)
	458	strcpy(hrec, "RAID-4");
	459	else if (pai->ai_type == 5)
	460	strcpy(hrec, "RAID-5");
	461	else
	462	strcpy(hrec, "RAID-10");
3e0552ee	463	seq_printf(m,
1da177e4 LT	464	" Capacity [MB]:\t%-6d \tType: \t%s\n",
	465	pai->ai_size/(1024*1024/pai->ai_secsize),
	466	hrec);
1da177e4 LT	467	}
1da177e4 LT	468	}
8d22022c	469
3e0552ee	470	if (!flag)
91c40f24	471	seq_puts(m, "\n --\n");
1da177e4 LT	472
1da177e4 LT	473	/* 5. about host drives */
91c40f24	474	seq_puts(m, "\nHost Drives:");
1da177e4 LT	475	flag = FALSE;
1da177e4 LT	476
1da177e4 LT	477	for (i = 0; i < MAX_LDRIVES; ++i) {
	478	if (!ha->hdr[i].is_logdrv \|\|
	479	(ha->hdr[i].is_arraydrv && !ha->hdr[i].is_master))
	480	continue;
	481	/* 5.a get host drive list */
	482	TRACE2(("host_get() drv_no %d\n",i));
	483	phg = (gdth_hget_str *)buf;
	484	gdtcmd->Service = CACHESERVICE;
	485	gdtcmd->OpCode = GDT_IOCTL;
	486	gdtcmd->u.ioctl.p_param = paddr;
	487	gdtcmd->u.ioctl.param_size = sizeof(gdth_hget_str);
	488	gdtcmd->u.ioctl.subfunc = HOST_GET \| LA_CTRL_PATTERN;
	489	gdtcmd->u.ioctl.channel = i;
	490	phg->entries = MAX_HDRIVES;
	491	phg->offset = GDTOFFSOF(gdth_hget_str, entry[0]);
cbd5f69b	492	if (gdth_execute(host, gdtcmd, cmnd, 30, NULL) == S_OK) {
1da177e4 LT	493	ha->hdr[i].ldr_no = i;
	494	ha->hdr[i].rw_attribs = 0;
	495	ha->hdr[i].start_sec = 0;
	496	} else {
	497	for (j = 0; j < phg->entries; ++j) {
	498	k = phg->entry[j].host_drive;
	499	if (k >= MAX_LDRIVES)
	500	continue;
	501	ha->hdr[k].ldr_no = phg->entry[j].log_drive;
	502	ha->hdr[k].rw_attribs = phg->entry[j].rw_attribs;
	503	ha->hdr[k].start_sec = phg->entry[j].start_sec;
	504	}
	505	}
	506	}
bb327df8	507	dma_free_coherent(&ha->pdev->dev, size, buf, paddr);
1da177e4 LT	508
	509	for (i = 0; i < MAX_HDRIVES; ++i) {
	510	if (!(ha->hdr[i].present))
	511	continue;
	512
3e0552ee	513	seq_printf(m,
1da177e4 LT	514	"\n Number: \t%-2d \tArr/Log. Drive:\t%d\n",
1da177e4 LT	515	i, ha->hdr[i].ldr_no);
1da177e4 LT	516	flag = TRUE;
1da177e4 LT	517
3e0552ee	518	seq_printf(m,
1da177e4	519	" Capacity [MB]:\t%-6d \tStart Sector: \t%d\n",
1fe6dbf4	520	(u32)(ha->hdr[i].size/2048), ha->hdr[i].start_sec);
1da177e4 LT	521	}
1da177e4 LT	522
3e0552ee	523	if (!flag)
91c40f24	524	seq_puts(m, "\n --\n");
1da177e4 LT	525	}
	526
	527	/* controller events */
91c40f24	528	seq_puts(m, "\nController Events:\n");
1da177e4 LT	529
	530	for (id = -1;;) {
	531	id = gdth_read_event(ha, id, estr);
	532	if (estr->event_source == 0)
	533	break;
45f1a41b	534	if (estr->event_data.eu.driver.ionode == ha->hanum &&
1da177e4 LT	535	estr->event_source == ES_ASYNC) {
1da177e4 LT	536	gdth_log_event(&estr->event_data, hrec);
5a412c38 AS	537
	538	/*
	539	* Elapsed seconds subtraction with unsigned operands is
	540	* safe from wrap around in year 2106. Executes as:
	541	* operand a + (2's complement operand b) + 1
	542	*/
	543
	544	sec = (int)((u32)ktime_get_real_seconds() - estr->first_stamp);
1da177e4	545	if (sec < 0) sec = 0;
3e0552ee	546	seq_printf(m," date- %02d:%02d:%02d\t%s\n",
1da177e4	547	sec/3600, sec%3600/60, sec%60, hrec);
1da177e4 LT	548	}
	549	if (id == -1)
	550	break;
	551	}
1da177e4	552	stop_output:
3e0552ee	553	rc = 0;
1da177e4 LT	554	free_fail:
	555	kfree(gdtcmd);
	556	kfree(estr);
	557	return rc;
	558	}
	559
45f1a41b	560	static void gdth_wait_completion(gdth_ha_str *ha, int busnum, int id)
1da177e4	561	{
1fe6dbf4	562	unsigned long flags;
1da177e4	563	int i;
91ebc1fa	564	struct scsi_cmnd *scp;
f842b64e	565	struct gdth_cmndinfo *cmndinfo;
1fe6dbf4	566	u8 b, t;
1da177e4	567
1da177e4 LT	568	spin_lock_irqsave(&ha->smp_lock, flags);
	569
	570	for (i = 0; i < GDTH_MAXCMDS; ++i) {
	571	scp = ha->cmd_tab[i].cmnd;
f842b64e	572	cmndinfo = gdth_cmnd_priv(scp);
1da177e4	573
52759e6a	574	b = scp->device->channel;
1da177e4	575	t = scp->device->id;
1fe6dbf4 DJ	576	if (!SPECIAL_SCP(scp) && t == (u8)id &&
1fe6dbf4 DJ	577	b == (u8)busnum) {
f842b64e	578	cmndinfo->wait_for_completion = 0;
1da177e4	579	spin_unlock_irqrestore(&ha->smp_lock, flags);
f842b64e	580	while (!cmndinfo->wait_for_completion)
1da177e4 LT	581	barrier();
	582	spin_lock_irqsave(&ha->smp_lock, flags);
	583	}
	584	}
	585	spin_unlock_irqrestore(&ha->smp_lock, flags);
	586	}