gdth_proc.c

linux和2410结合开发 用他可以生成2410所需的zImage文件

                ha->hdr[j].lock = 0;
                GDTH_UNLOCK_HA(ha, flags);
                gdth_start_timeout( hanum, ha->bus_cnt, j );
                gdth_next( hanum );
            }
        }
        piord->size = sizeof(gdth_iord_str);
        piord->status = S_OK;
        break;

      case GDTIOCTL_LOCKCHN:
        if (!gdth_ioctl_alloc( hanum, sizeof(gdth_iord_str), TRUE ))
            return(-EBUSY);
        i = piowr->iu.lockchn.channel;
        if (i < ha->bus_cnt) {
            if (piowr->iu.lockchn.lock) {
                GDTH_LOCK_HA(ha, flags);
                ha->raw[i].lock = 1;
                GDTH_UNLOCK_HA(ha, flags);
                for (j = 0; j < ha->tid_cnt; ++j) {
                    gdth_wait_completion( hanum, i, j );
                    gdth_stop_timeout( hanum, i, j );
                }
            } else {
                GDTH_LOCK_HA(ha, flags);
                ha->raw[i].lock = 0;
                GDTH_UNLOCK_HA(ha, flags);
                for (j = 0; j < ha->tid_cnt; ++j) {
                    gdth_start_timeout( hanum, i, j );
                    gdth_next( hanum );
                }
            }
        }
        piord = (gdth_iord_str *)ha->pscratch;
        piord->size = sizeof(gdth_iord_str);
        piord->status = S_OK;
        break;

      case GDTIOCTL_EVENT:
        if (!gdth_ioctl_alloc( hanum, sizeof(gdth_iord_str), TRUE ))
            return(-EBUSY);
        piord = (gdth_iord_str *)ha->pscratch;
        if (piowr->iu.event.erase == 0xff) {
            pevt = (gdth_evt_str *)piowr->iu.event.evt;
            if (pevt->event_source == ES_TEST) 
                pevt->event_data.size = sizeof(pevt->event_data.eu.test);
            else if (pevt->event_source == ES_DRIVER) 
                pevt->event_data.size = sizeof(pevt->event_data.eu.driver);
            else if (pevt->event_source == ES_SYNC) 
                pevt->event_data.size = sizeof(pevt->event_data.eu.sync);
            else {
                pevt->event_data.size = sizeof(pevt->event_data.eu.async);
                gdth_log_event(&pevt->event_data, NULL);
            }
            GDTH_LOCK_HA(ha, flags);
            gdth_store_event(ha, pevt->event_source, pevt->event_idx,
                             &pevt->event_data);
            GDTH_UNLOCK_HA(ha, flags);
        } else if (piowr->iu.event.erase == 0xfe) {
            gdth_clear_events();
        } else if (piowr->iu.event.erase == 0) {
            piord->iu.event.handle = 
                gdth_read_event(ha,piowr->iu.event.handle,
                                (gdth_evt_str *)piord->iu.event.evt);
        } else {
            piord->iu.event.handle = piowr->iu.event.handle;
            gdth_readapp_event(ha, (unchar)piowr->iu.event.erase,
                               (gdth_evt_str *)piord->iu.event.evt);
        }
        piord->size = sizeof(gdth_iord_str);
        piord->status = S_OK;
        break;

      case GDTIOCTL_SCSI:
        if (!gdth_ioctl_alloc( hanum, sizeof(gdth_iord_str), TRUE ))
            return(-EBUSY);
        piord = (gdth_iord_str *)ha->pscratch;
        piord->size = sizeof(gdth_iord_str);
        memcpy(cmnd, piowr->iu.scsi.cmd, 12);
#if LINUX_VERSION_CODE >= 0x020322
        scp->target = piowr->iu.scsi.target;
        scp->channel = virt_ctr ? 0 : piowr->iu.scsi.bus;
        scp->cmd_len = piowr->iu.scsi.cmd_len;
        gdth_do_cmd(scp, pcmd, cmnd, piowr->timeout);
        piord->status = (scp->SCp.Message<<16)|scp->SCp.Status;
#else
        scp.target = piowr->iu.scsi.target;
        scp.channel = virt_ctr ? 0 : piowr->iu.scsi.bus;
        scp.cmd_len = piowr->iu.scsi.cmd_len;
        gdth_do_cmd(&scp, pcmd, cmnd, piowr->timeout);
        piord->status = (scp.SCp.Message<<16)|scp.SCp.Status;
#endif
        break;

      case GDTIOCTL_RESET_BUS:
        if (!gdth_ioctl_alloc( hanum, sizeof(gdth_iord_str), TRUE ))
            return(-EBUSY);
        piord = (gdth_iord_str *)ha->pscratch;
        piord->size = sizeof(gdth_iord_str);
#if LINUX_VERSION_CODE >= 0x020322
        scp->channel = virt_ctr ? 0 : piowr->iu.scsi.bus;
        piord->status = (ulong32)gdth_eh_bus_reset( scp );
        if (piord->status == SUCCESS)
            piord->status = S_OK;
        else
            piord->status = S_GENERR;
#elif LINUX_VERSION_CODE >= 0x02015F
        scp.channel = virt_ctr ? 0 : piowr->iu.scsi.bus;
        piord->status = (ulong32)gdth_eh_bus_reset( &scp );
        if (piord->status == SUCCESS)
            piord->status = S_OK;
        else
            piord->status = S_GENERR;
#else
        piord->status = S_OK;
#endif
        break;

      case GDTIOCTL_HDRLIST:
        if (!gdth_ioctl_alloc( hanum, sizeof(gdth_iord_str), TRUE ))
            return(-EBUSY);
        piord = (gdth_iord_str *)ha->pscratch;
        piord->size = sizeof(gdth_iord_str);
        piord->status = S_OK;
        for (i = 0; i < MAX_HDRIVES; ++i) {
            if (ha->hdr[i].present) {
                piord->iu.hdr_list[i].bus = ha->virt_bus;
                piord->iu.hdr_list[i].target = i;
                piord->iu.hdr_list[i].lun = 0;
                piord->iu.hdr_list[i].cluster_type = ha->hdr[i].cluster_type;
                if (ha->hdr[i].cluster_type & CLUSTER_DRIVE) {  
                    gdtcmd.Service = CACHESERVICE;
                    gdtcmd.OpCode = GDT_CLUST_INFO;
                    gdtcmd.u.cache.DeviceNo = i;
#if LINUX_VERSION_CODE >= 0x020322
                    gdth_do_cmd(scp, &gdtcmd, cmnd, 30);
                    if (scp->SCp.Status == S_OK)
                        piord->iu.hdr_list[i].cluster_type = 
                            (unchar)scp->SCp.Message;
#else
                    gdth_do_cmd(&scp, &gdtcmd, cmnd, 30);
                    if (scp.SCp.Status == S_OK)
                        piord->iu.hdr_list[i].cluster_type = 
                            (unchar)scp.SCp.Message;
#endif
                }
            } else {
                piord->iu.hdr_list[i].bus = 0xff;
            }
        }
        break;

      case GDTIOCTL_RESCAN:
        if (!gdth_ioctl_alloc( hanum, sizeof(gdth_iord_str), TRUE ))
            return(-EBUSY);
        piord = (gdth_iord_str *)ha->pscratch;
        piord->size = sizeof(gdth_iord_str);
        piord->status = S_OK;
        if (piowr->iu.rescan.flag == 0) {
            /* old method: scan all host drives 
               re-initialize cache service to get host drive count
            */
            gdtcmd.Service = CACHESERVICE;
            gdtcmd.OpCode = GDT_INIT;
            gdtcmd.u.cache.DeviceNo = LINUX_OS;
#if LINUX_VERSION_CODE >= 0x020322
            gdth_do_cmd(scp, &gdtcmd, cmnd, 30);
            status = (ushort)scp->SCp.Status; 
            info = (ulong32)scp->SCp.Message;
#else
            gdth_do_cmd(&scp, &gdtcmd, cmnd, 30);
            status = (ushort)scp.SCp.Status;
            info = (ulong32)scp.SCp.Message;
#endif
            if (status != S_OK)
                break;
            k = 0;
            hdr_cnt = (ushort)info;
        } else {
            k = piowr->iu.rescan.hdr_no;
            hdr_cnt = k + 1;
        }
        if (hdr_cnt > MAX_HDRIVES)
            hdr_cnt = MAX_HDRIVES;
        /* scanning for host drives */
        for (; k < hdr_cnt; ++k) {
            /* info about host drive */
            gdtcmd.Service = CACHESERVICE;
            gdtcmd.OpCode = GDT_INFO;
            gdtcmd.u.cache.DeviceNo = k;
#if LINUX_VERSION_CODE >= 0x020322
            gdth_do_cmd(scp, &gdtcmd, cmnd, 30);
            status = (ushort)scp->SCp.Status; 
            info = (ulong32)scp->SCp.Message;
#else
            gdth_do_cmd(&scp, &gdtcmd, cmnd, 30);
            status = (ushort)scp.SCp.Status;
            info = (ulong32)scp.SCp.Message;
#endif
            GDTH_LOCK_HA(ha, flags);
            piord->iu.hdr_list[k].bus = ha->virt_bus;
            piord->iu.hdr_list[k].target = k;
            piord->iu.hdr_list[k].lun = 0;
            if (status != S_OK) {
                ha->hdr[k].present = FALSE;
            } else {
                ha->hdr[k].present = TRUE;
                ha->hdr[k].size = info;
                /* evaluate mapping (sectors per head, heads per cylinder) */
                ha->hdr[k].size &= ~SECS32;
                gdth_eval_mapping(ha->hdr[k].size,&drv_cyls,&drv_hds,&drv_secs);
                ha->hdr[k].heads = (unchar)drv_hds;
                ha->hdr[k].secs = (unchar)drv_secs;
                /* round size */
                ha->hdr[k].size = drv_cyls * drv_hds * drv_secs;
            }
            GDTH_UNLOCK_HA(ha, flags);
            if (status != S_OK)
                continue;       /* next host drive */

            /* devtype, cluster info, R/W attributes */
            gdtcmd.Service = CACHESERVICE;
            gdtcmd.OpCode = GDT_DEVTYPE;
            gdtcmd.u.cache.DeviceNo = k;
#if LINUX_VERSION_CODE >= 0x020322
            gdth_do_cmd(scp, &gdtcmd, cmnd, 30);
            status = (ushort)scp->SCp.Status; 
            info = (ulong32)scp->SCp.Message;
#else
            gdth_do_cmd(&scp, &gdtcmd, cmnd, 30);
            status = (ushort)scp.SCp.Status;
            info = (ulong32)scp.SCp.Message;
#endif
            GDTH_LOCK_HA(ha, flags);
            ha->hdr[k].devtype = 0;
            if (status == S_OK)
                ha->hdr[k].devtype = (ushort)info;
            GDTH_UNLOCK_HA(ha, flags);

            gdtcmd.Service = CACHESERVICE;
            gdtcmd.OpCode = GDT_CLUST_INFO;
            gdtcmd.u.cache.DeviceNo = k;
#if LINUX_VERSION_CODE >= 0x020322
            gdth_do_cmd(scp, &gdtcmd, cmnd, 30);
            status = (ushort)scp->SCp.Status; 
            info = (ulong32)scp->SCp.Message;
#else
            gdth_do_cmd(&scp, &gdtcmd, cmnd, 30);
            status = (ushort)scp.SCp.Status;
            info = (ulong32)scp.SCp.Message;
#endif
            GDTH_LOCK_HA(ha, flags);
            ha->hdr[k].cluster_type = 0;
            if (status == S_OK && !shared_access)
                ha->hdr[k].cluster_type = (ushort)info;
            GDTH_UNLOCK_HA(ha, flags);
            piord->iu.hdr_list[k].cluster_type = ha->hdr[k].cluster_type;

            gdtcmd.Service = CACHESERVICE;
            gdtcmd.OpCode = GDT_RW_ATTRIBS;
            gdtcmd.u.cache.DeviceNo = k;
#if LINUX_VERSION_CODE >= 0x020322
            gdth_do_cmd(scp, &gdtcmd, cmnd, 30);
            status = (ushort)scp->SCp.Status; 
            info = (ulong32)scp->SCp.Message;
#else
            gdth_do_cmd(&scp, &gdtcmd, cmnd, 30);
            status = (ushort)scp.SCp.Status;
            info = (ulong32)scp.SCp.Message;
#endif
            GDTH_LOCK_HA(ha, flags);
            ha->hdr[k].rw_attribs = 0;
            if (status == S_OK)
                ha->hdr[k].rw_attribs = (ushort)info;
            GDTH_UNLOCK_HA(ha, flags);
        }
        break;

      case GDTIOCTL_RESET_DRV:
        if (!gdth_ioctl_alloc( hanum, sizeof(gdth_iord_str), TRUE ))
            return(-EBUSY);
        piord = (gdth_iord_str *)ha->pscratch;
        piord->size = sizeof(gdth_iord_str);
        piord->status = S_OK;
        i = piowr->iu.scsi.target;
        if (ha->hdr[i].present) {
            gdtcmd.Service = CACHESERVICE;
            gdtcmd.OpCode = GDT_CLUST_RESET;
            gdtcmd.u.cache.DeviceNo = i;
#if LINUX_VERSION_CODE >= 0x020322
            gdth_do_cmd(scp, &gdtcmd, cmnd, 30);
            piord->status = (scp->SCp.Message<<16)|scp->SCp.Status;
#else
            gdth_do_cmd(&scp, &gdtcmd, cmnd, 30);
            piord->status = (scp.SCp.Message<<16)|scp.SCp.Status;
#endif
        }
        break;

      default:
        return(-EINVAL);
    }
    return length;
}

static int gdth_get_info(char *buffer,char **start,off_t offset,
                         int length,int vh,int hanum,int busnum)
{
    int size = 0,len = 0;
    off_t begin = 0,pos = 0;
    gdth_ha_str *ha;
    gdth_iord_str *piord;
    int id, i, j, k, sec, flag;
    int no_mdrv = 0, drv_no, is_mirr;
    ulong32 cnt;

    gdth_cmd_str gdtcmd;
    gdth_evt_str estr;
#if LINUX_VERSION_CODE >= 0x020322
    Scsi_Cmnd *scp;
    Scsi_Device *sdev;
#else
    Scsi_Cmnd scp;
    Scsi_Device sdev;
#endif
    char hrec[161];
    struct timeval tv;

    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];
    memset(cmnd, 0xff, 12);
    memset(&gdtcmd, 0, sizeof(gdth_cmd_str));

    TRACE2(("gdth_get_info() ha %d bus %d\n",hanum,busnum));
    ha = HADATA(gdth_ctr_tab[hanum]);

#if LINUX_VERSION_CODE >= 0x020322
    sdev = scsi_get_host_dev(gdth_ctr_vtab[vh]);
    scp  = scsi_allocate_device(sdev, 1, FALSE);
    if (!scp)
        return -ENOMEM;
    scp->cmd_len = 12;
    scp->use_sg = 0;
#else
    memset(&sdev,0,sizeof(Scsi_Device));
    memset(&scp, 0,sizeof(Scsi_Cmnd));
    sdev.host = scp.host = gdth_ctr_vtab[vh];
    sdev.id = scp.target = sdev.host->this_id;
    scp.device = &sdev;
#endif

    /* ioctl from tool? */
    if (!gdth_ioctl_check_bin(hanum, (ushort)length)) {
        /* request is i.e. "cat /proc/scsi/gdth/0" */ 
        /* format: %-15s\t%-10s\t%-15s\t%s */
        /* driver parameters */
        size = sprintf(buffer+len,"Driver Parameters:\n");
        len += size;  pos = begin + len;
        if (reserve_list[0] == 0xff)
            strcpy(hrec, "--");
        else {
            sprintf(hrec, "%d", reserve_list[0]);