Merge branch 'master'
[linux-2.6.git] / drivers / scsi / gdth_proc.c
1 /* gdth_proc.c 
2  * $Id: gdth_proc.c,v 1.42 2004/03/05 15:50:20 achim Exp $
3  */
4
5 #include <linux/completion.h>
6
7 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
8 int gdth_proc_info(struct Scsi_Host *host, char *buffer,char **start,off_t offset,int length,   
9                    int inout)
10 {
11     int hanum,busnum;
12
13     TRACE2(("gdth_proc_info() length %d offs %d inout %d\n",
14             length,(int)offset,inout));
15
16     hanum = NUMDATA(host)->hanum;
17     busnum= NUMDATA(host)->busnum;
18
19     if (inout)
20         return(gdth_set_info(buffer,length,host,hanum,busnum));
21     else
22         return(gdth_get_info(buffer,start,offset,length,host,hanum,busnum));
23 }
24 #else
25 int gdth_proc_info(char *buffer,char **start,off_t offset,int length,int hostno,   
26                    int inout)
27 {
28     int hanum,busnum,i;
29
30     TRACE2(("gdth_proc_info() length %d offs %d inout %d\n",
31             length,(int)offset,inout));
32
33     for (i = 0; i < gdth_ctr_vcount; ++i) {
34         if (gdth_ctr_vtab[i]->host_no == hostno)
35             break;
36     }
37     if (i == gdth_ctr_vcount)
38         return(-EINVAL);
39
40     hanum = NUMDATA(gdth_ctr_vtab[i])->hanum;
41     busnum= NUMDATA(gdth_ctr_vtab[i])->busnum;
42
43     if (inout)
44         return(gdth_set_info(buffer,length,gdth_ctr_vtab[i],hanum,busnum));
45     else
46         return(gdth_get_info(buffer,start,offset,length,
47                              gdth_ctr_vtab[i],hanum,busnum));
48 }
49 #endif
50
51 static int gdth_set_info(char *buffer,int length,struct Scsi_Host *host,
52                          int hanum,int busnum)
53 {
54     int             ret_val = -EINVAL;
55 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
56     Scsi_Request    *scp;
57     struct scsi_device     *sdev;
58 #else
59     Scsi_Cmnd       *scp;
60     struct scsi_device     *sdev;
61 #endif
62     TRACE2(("gdth_set_info() ha %d bus %d\n",hanum,busnum));
63
64 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
65     sdev = scsi_get_host_dev(host);
66     scp  = scsi_allocate_request(sdev, GFP_KERNEL);
67     if (!scp)
68         return -ENOMEM;
69     scp->sr_cmd_len = 12;
70     scp->sr_use_sg = 0;
71 #else
72     sdev = scsi_get_host_dev(host);
73     scp  = scsi_allocate_device(sdev, 1, FALSE);
74     if (!scp)
75         return -ENOMEM;
76     scp->cmd_len = 12;
77     scp->use_sg = 0;
78 #endif
79
80     if (length >= 4) {
81         if (strncmp(buffer,"gdth",4) == 0) {
82             buffer += 5;
83             length -= 5;
84             ret_val = gdth_set_asc_info( buffer, length, hanum, scp );
85         }
86     }
87 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
88     scsi_release_request(scp);
89     scsi_free_host_dev(sdev);
90 #else
91     scsi_release_command(scp);
92     scsi_free_host_dev(sdev);
93 #endif
94     return ret_val;
95 }
96          
97 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
98 static int gdth_set_asc_info(char *buffer,int length,int hanum,Scsi_Request *scp)
99 #else
100 static int gdth_set_asc_info(char *buffer,int length,int hanum,Scsi_Cmnd *scp)
101 #endif
102 {
103     int             orig_length, drive, wb_mode;
104     int             i, found;
105     gdth_ha_str     *ha;
106     gdth_cmd_str    gdtcmd;
107     gdth_cpar_str   *pcpar;
108     ulong64         paddr;
109
110     char            cmnd[MAX_COMMAND_SIZE];
111     memset(cmnd, 0xff, 12);
112     memset(&gdtcmd, 0, sizeof(gdth_cmd_str));
113
114     TRACE2(("gdth_set_asc_info() ha %d\n",hanum));
115     ha = HADATA(gdth_ctr_tab[hanum]);
116     orig_length = length + 5;
117     drive = -1;
118     wb_mode = 0;
119     found = FALSE;
120
121     if (length >= 5 && strncmp(buffer,"flush",5)==0) {
122         buffer += 6;
123         length -= 6;
124         if (length && *buffer>='0' && *buffer<='9') {
125             drive = (int)(*buffer-'0');
126             ++buffer; --length;
127             if (length && *buffer>='0' && *buffer<='9') {
128                 drive = drive*10 + (int)(*buffer-'0');
129                 ++buffer; --length;
130             }
131             printk("GDT: Flushing host drive %d .. ",drive);
132         } else {
133             printk("GDT: Flushing all host drives .. ");
134         }
135         for (i = 0; i < MAX_HDRIVES; ++i) {
136             if (ha->hdr[i].present) {
137                 if (drive != -1 && i != drive)
138                     continue;
139                 found = TRUE;
140                 gdtcmd.Service = CACHESERVICE;
141                 gdtcmd.OpCode = GDT_FLUSH;
142                 if (ha->cache_feat & GDT_64BIT) {
143                     gdtcmd.u.cache64.DeviceNo = i;
144                     gdtcmd.u.cache64.BlockNo = 1;
145                 } else {
146                     gdtcmd.u.cache.DeviceNo = i;
147                     gdtcmd.u.cache.BlockNo = 1;
148                 }
149 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
150                 gdth_do_req(scp, &gdtcmd, cmnd, 30);
151 #else
152                 gdth_do_cmd(scp, &gdtcmd, cmnd, 30);
153 #endif
154             }
155         }
156         if (!found)
157             printk("\nNo host drive found !\n");
158         else
159             printk("Done.\n");
160         return(orig_length);
161     }
162
163     if (length >= 7 && strncmp(buffer,"wbp_off",7)==0) {
164         buffer += 8;
165         length -= 8;
166         printk("GDT: Disabling write back permanently .. ");
167         wb_mode = 1;
168     } else if (length >= 6 && strncmp(buffer,"wbp_on",6)==0) {
169         buffer += 7;
170         length -= 7;
171         printk("GDT: Enabling write back permanently .. ");
172         wb_mode = 2;
173     } else if (length >= 6 && strncmp(buffer,"wb_off",6)==0) {
174         buffer += 7;
175         length -= 7;
176         printk("GDT: Disabling write back commands .. ");
177         if (ha->cache_feat & GDT_WR_THROUGH) {
178             gdth_write_through = TRUE;
179             printk("Done.\n");
180         } else {
181             printk("Not supported !\n");
182         }
183         return(orig_length);
184     } else if (length >= 5 && strncmp(buffer,"wb_on",5)==0) {
185         buffer += 6;
186         length -= 6;
187         printk("GDT: Enabling write back commands .. ");
188         gdth_write_through = FALSE;
189         printk("Done.\n");
190         return(orig_length);
191     }
192
193     if (wb_mode) {
194         if (!gdth_ioctl_alloc(hanum, sizeof(gdth_cpar_str), TRUE, &paddr))
195             return(-EBUSY);
196         pcpar = (gdth_cpar_str *)ha->pscratch;
197         memcpy( pcpar, &ha->cpar, sizeof(gdth_cpar_str) );
198         gdtcmd.Service = CACHESERVICE;
199         gdtcmd.OpCode = GDT_IOCTL;
200         gdtcmd.u.ioctl.p_param = paddr;
201         gdtcmd.u.ioctl.param_size = sizeof(gdth_cpar_str);
202         gdtcmd.u.ioctl.subfunc = CACHE_CONFIG;
203         gdtcmd.u.ioctl.channel = INVALID_CHANNEL;
204         pcpar->write_back = wb_mode==1 ? 0:1;
205 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
206         gdth_do_req(scp, &gdtcmd, cmnd, 30);
207 #else
208         gdth_do_cmd(scp, &gdtcmd, cmnd, 30);
209 #endif
210         gdth_ioctl_free(hanum, GDTH_SCRATCH, ha->pscratch, paddr);
211         printk("Done.\n");
212         return(orig_length);
213     }
214
215     printk("GDT: Unknown command: %s  Length: %d\n",buffer,length);
216     return(-EINVAL);
217 }
218
219 static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
220                          struct Scsi_Host *host,int hanum,int busnum)
221 {
222     int size = 0,len = 0;
223     off_t begin = 0,pos = 0;
224     gdth_ha_str *ha;
225     int id, i, j, k, sec, flag;
226     int no_mdrv = 0, drv_no, is_mirr;
227     ulong32 cnt;
228     ulong64 paddr;
229     int rc = -ENOMEM;
230
231     gdth_cmd_str *gdtcmd;
232     gdth_evt_str *estr;
233 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
234     Scsi_Request *scp;
235     struct scsi_device *sdev;
236 #else
237     Scsi_Cmnd *scp;
238     struct scsi_device *sdev;
239 #endif
240     char hrec[161];
241     struct timeval tv;
242
243     char *buf;
244     gdth_dskstat_str *pds;
245     gdth_diskinfo_str *pdi;
246     gdth_arrayinf_str *pai;
247     gdth_defcnt_str *pdef;
248     gdth_cdrinfo_str *pcdi;
249     gdth_hget_str *phg;
250     char cmnd[MAX_COMMAND_SIZE];
251
252     gdtcmd = kmalloc(sizeof(*gdtcmd), GFP_KERNEL);
253     estr = kmalloc(sizeof(*estr), GFP_KERNEL);
254     if (!gdtcmd || !estr)
255         goto free_fail;
256
257     memset(cmnd, 0xff, 12);
258     memset(gdtcmd, 0, sizeof(gdth_cmd_str));
259
260     TRACE2(("gdth_get_info() ha %d bus %d\n",hanum,busnum));
261     ha = HADATA(gdth_ctr_tab[hanum]);
262
263 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
264     sdev = scsi_get_host_dev(host);
265     scp  = scsi_allocate_request(sdev, GFP_KERNEL);
266     if (!scp)
267         goto free_fail;
268     scp->sr_cmd_len = 12;
269     scp->sr_use_sg = 0;
270 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
271     sdev = scsi_get_host_dev(host);
272     scp  = scsi_allocate_device(sdev, 1, FALSE);
273     if (!scp)
274         goto free_fail;
275     scp->cmd_len = 12;
276     scp->use_sg = 0;
277 #else
278     memset(&sdev,0,sizeof(struct scsi_device));
279     memset(&scp, 0,sizeof(Scsi_Cmnd));
280     sdev.host = scp.host = host;
281     sdev.id = scp.target = sdev.host->this_id;
282     scp.device = &sdev;
283 #endif
284     
285     
286     /* request is i.e. "cat /proc/scsi/gdth/0" */ 
287     /* format: %-15s\t%-10s\t%-15s\t%s */
288     /* driver parameters */
289     size = sprintf(buffer+len,"Driver Parameters:\n");
290     len += size;  pos = begin + len;
291     if (reserve_list[0] == 0xff)
292         strcpy(hrec, "--");
293     else {
294         sprintf(hrec, "%d", reserve_list[0]);
295         for (i = 1;  i < MAX_RES_ARGS; i++) {
296             if (reserve_list[i] == 0xff) 
297                 break;
298             sprintf(hrec,"%s,%d", hrec, reserve_list[i]);
299         }
300     }
301     size = sprintf(buffer+len,
302                    " reserve_mode: \t%d         \treserve_list:  \t%s\n",
303                    reserve_mode, hrec);
304     len += size;  pos = begin + len;
305     size = sprintf(buffer+len,
306                    " max_ids:      \t%-3d       \thdr_channel:   \t%d\n",
307                    max_ids, hdr_channel);
308     len += size;  pos = begin + len;
309
310     /* controller information */
311     size = sprintf(buffer+len,"\nDisk Array Controller Information:\n");
312     len += size;  pos = begin + len;
313     if (virt_ctr)
314         sprintf(hrec, "%s (Bus %d)", ha->binfo.type_string, busnum);
315     else
316         strcpy(hrec, ha->binfo.type_string);
317     size = sprintf(buffer+len,
318                    " Number:       \t%d         \tName:          \t%s\n",
319                    hanum, hrec);
320     len += size;  pos = begin + len;
321
322     if (ha->more_proc)
323         sprintf(hrec, "%d.%02d.%02d-%c%03X", 
324                 (unchar)(ha->binfo.upd_fw_ver>>24),
325                 (unchar)(ha->binfo.upd_fw_ver>>16),
326                 (unchar)(ha->binfo.upd_fw_ver),
327                 ha->bfeat.raid ? 'R':'N',
328                 ha->binfo.upd_revision);
329     else
330         sprintf(hrec, "%d.%02d", (unchar)(ha->cpar.version>>8),
331                 (unchar)(ha->cpar.version));
332
333     size = sprintf(buffer+len,
334                    " Driver Ver.:  \t%-10s\tFirmware Ver.: \t%s\n",
335                    GDTH_VERSION_STR, hrec);
336     len += size;  pos = begin + len;
337  
338     if (ha->more_proc) {
339         /* more information: 1. about controller */
340         size = sprintf(buffer+len,
341                        " Serial No.:   \t0x%8X\tCache RAM size:\t%d KB\n",
342                        ha->binfo.ser_no, ha->binfo.memsize / 1024);
343         len += size;  pos = begin + len;
344     }
345
346 #ifdef GDTH_DMA_STATISTICS
347     /* controller statistics */
348     size = sprintf(buffer+len,"\nController Statistics:\n");
349     len += size;  pos = begin + len;
350     size = sprintf(buffer+len,
351                    " 32-bit DMA buffer:\t%lu\t64-bit DMA buffer:\t%lu\n",
352                    ha->dma32_cnt, ha->dma64_cnt);
353     len += size;  pos = begin + len;
354 #endif
355
356     if (pos < offset) {
357         len = 0;
358         begin = pos;
359     }
360     if (pos > offset + length)
361         goto stop_output;
362
363     if (ha->more_proc) {
364         /* more information: 2. about physical devices */
365         size = sprintf(buffer+len,"\nPhysical Devices:");
366         len += size;  pos = begin + len;
367         flag = FALSE;
368             
369         buf = gdth_ioctl_alloc(hanum, GDTH_SCRATCH, FALSE, &paddr);
370         if (!buf) 
371             goto stop_output;
372         for (i = 0; i < ha->bus_cnt; ++i) {
373             /* 2.a statistics (and retries/reassigns) */
374             TRACE2(("pdr_statistics() chn %d\n",i));                
375             pds = (gdth_dskstat_str *)(buf + GDTH_SCRATCH/4);
376             gdtcmd->Service = CACHESERVICE;
377             gdtcmd->OpCode = GDT_IOCTL;
378             gdtcmd->u.ioctl.p_param = paddr + GDTH_SCRATCH/4;
379             gdtcmd->u.ioctl.param_size = 3*GDTH_SCRATCH/4;
380             gdtcmd->u.ioctl.subfunc = DSK_STATISTICS | L_CTRL_PATTERN;
381             gdtcmd->u.ioctl.channel = ha->raw[i].address | INVALID_CHANNEL;
382             pds->bid = ha->raw[i].local_no;
383             pds->first = 0;
384             pds->entries = ha->raw[i].pdev_cnt;
385             cnt = (3*GDTH_SCRATCH/4 - 5 * sizeof(ulong32)) /
386                 sizeof(pds->list[0]);
387             if (pds->entries > cnt)
388                 pds->entries = cnt;
389 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
390             gdth_do_req(scp, gdtcmd, cmnd, 30);
391             if (scp->sr_command->SCp.Status != S_OK) 
392 #else
393             gdth_do_cmd(scp, gdtcmd, cmnd, 30);
394             if (scp->SCp.Status != S_OK) 
395 #endif
396             { 
397                 pds->count = 0;
398             }
399
400             /* other IOCTLs must fit into area GDTH_SCRATCH/4 */
401             for (j = 0; j < ha->raw[i].pdev_cnt; ++j) {
402                 /* 2.b drive info */
403                 TRACE2(("scsi_drv_info() chn %d dev %d\n",
404                     i, ha->raw[i].id_list[j]));             
405                 pdi = (gdth_diskinfo_str *)buf;
406                 gdtcmd->Service = CACHESERVICE;
407                 gdtcmd->OpCode = GDT_IOCTL;
408                 gdtcmd->u.ioctl.p_param = paddr;
409                 gdtcmd->u.ioctl.param_size = sizeof(gdth_diskinfo_str);
410                 gdtcmd->u.ioctl.subfunc = SCSI_DR_INFO | L_CTRL_PATTERN;
411                 gdtcmd->u.ioctl.channel = 
412                     ha->raw[i].address | ha->raw[i].id_list[j];
413 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
414                 gdth_do_req(scp, gdtcmd, cmnd, 30);
415                 if (scp->sr_command->SCp.Status == S_OK) 
416 #else
417                 gdth_do_cmd(scp, gdtcmd, cmnd, 30);
418                 if (scp->SCp.Status == S_OK) 
419 #endif
420                 {
421                     strncpy(hrec,pdi->vendor,8);
422                     strncpy(hrec+8,pdi->product,16);
423                     strncpy(hrec+24,pdi->revision,4);
424                     hrec[28] = 0;
425                     size = sprintf(buffer+len,
426                                    "\n Chn/ID/LUN:   \t%c/%02d/%d    \tName:          \t%s\n",
427                                    'A'+i,pdi->target_id,pdi->lun,hrec);
428                     len += size;  pos = begin + len;
429                     flag = TRUE;
430                     pdi->no_ldrive &= 0xffff;
431                     if (pdi->no_ldrive == 0xffff)
432                         strcpy(hrec,"--");
433                     else
434                         sprintf(hrec,"%d",pdi->no_ldrive);
435                     size = sprintf(buffer+len,
436                                    " Capacity [MB]:\t%-6d    \tTo Log. Drive: \t%s\n",
437                                    pdi->blkcnt/(1024*1024/pdi->blksize),
438                                    hrec);
439                     len += size;  pos = begin + len;
440                 } else {
441                     pdi->devtype = 0xff;
442                 }
443                     
444                 if (pdi->devtype == 0) {
445                     /* search retries/reassigns */
446                     for (k = 0; k < pds->count; ++k) {
447                         if (pds->list[k].tid == pdi->target_id &&
448                             pds->list[k].lun == pdi->lun) {
449                             size = sprintf(buffer+len,
450                                            " Retries:      \t%-6d    \tReassigns:     \t%d\n",
451                                            pds->list[k].retries,
452                                            pds->list[k].reassigns);
453                             len += size;  pos = begin + len;
454                             break;
455                         }
456                     }
457                     /* 2.c grown defects */
458                     TRACE2(("scsi_drv_defcnt() chn %d dev %d\n",
459                             i, ha->raw[i].id_list[j]));             
460                     pdef = (gdth_defcnt_str *)buf;
461                     gdtcmd->Service = CACHESERVICE;
462                     gdtcmd->OpCode = GDT_IOCTL;
463                     gdtcmd->u.ioctl.p_param = paddr;
464                     gdtcmd->u.ioctl.param_size = sizeof(gdth_defcnt_str);
465                     gdtcmd->u.ioctl.subfunc = SCSI_DEF_CNT | L_CTRL_PATTERN;
466                     gdtcmd->u.ioctl.channel = 
467                         ha->raw[i].address | ha->raw[i].id_list[j];
468                     pdef->sddc_type = 0x08;
469 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
470                     gdth_do_req(scp, gdtcmd, cmnd, 30);
471                     if (scp->sr_command->SCp.Status == S_OK) 
472 #else
473                     gdth_do_cmd(scp, gdtcmd, cmnd, 30);
474                     if (scp->SCp.Status == S_OK) 
475 #endif
476                     {
477                         size = sprintf(buffer+len,
478                                        " Grown Defects:\t%d\n",
479                                        pdef->sddc_cnt);
480                         len += size;  pos = begin + len;
481                     }
482                 }
483                 if (pos < offset) {
484                     len = 0;
485                     begin = pos;
486                 }
487                 if (pos > offset + length)
488                     goto stop_output;
489             }
490         }
491         gdth_ioctl_free(hanum, GDTH_SCRATCH, buf, paddr);
492
493         if (!flag) {
494             size = sprintf(buffer+len, "\n --\n");
495             len += size;  pos = begin + len;
496         }
497
498         /* 3. about logical drives */
499         size = sprintf(buffer+len,"\nLogical Drives:");
500         len += size;  pos = begin + len;
501         flag = FALSE;
502
503         buf = gdth_ioctl_alloc(hanum, GDTH_SCRATCH, FALSE, &paddr);
504         if (!buf) 
505             goto stop_output;
506         for (i = 0; i < MAX_LDRIVES; ++i) {
507             if (!ha->hdr[i].is_logdrv)
508                 continue;
509             drv_no = i;
510             j = k = 0;
511             is_mirr = FALSE;
512             do {
513                 /* 3.a log. drive info */
514                 TRACE2(("cache_drv_info() drive no %d\n",drv_no));
515                 pcdi = (gdth_cdrinfo_str *)buf;
516                 gdtcmd->Service = CACHESERVICE;
517                 gdtcmd->OpCode = GDT_IOCTL;
518                 gdtcmd->u.ioctl.p_param = paddr;
519                 gdtcmd->u.ioctl.param_size = sizeof(gdth_cdrinfo_str);
520                 gdtcmd->u.ioctl.subfunc = CACHE_DRV_INFO;
521                 gdtcmd->u.ioctl.channel = drv_no;
522 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
523                 gdth_do_req(scp, gdtcmd, cmnd, 30);
524                 if (scp->sr_command->SCp.Status != S_OK) 
525 #else
526                 gdth_do_cmd(scp, gdtcmd, cmnd, 30);
527                 if (scp->SCp.Status != S_OK)
528 #endif
529                 {
530                     break;
531                 }
532                 pcdi->ld_dtype >>= 16;
533                 j++;
534                 if (pcdi->ld_dtype > 2) {
535                     strcpy(hrec, "missing");
536                 } else if (pcdi->ld_error & 1) {
537                     strcpy(hrec, "fault");
538                 } else if (pcdi->ld_error & 2) {
539                     strcpy(hrec, "invalid");
540                     k++; j--;
541                 } else {
542                     strcpy(hrec, "ok");
543                 }
544                     
545                 if (drv_no == i) {
546                     size = sprintf(buffer+len,
547                                    "\n Number:       \t%-2d        \tStatus:        \t%s\n",
548                                    drv_no, hrec);
549                     len += size;  pos = begin + len;
550                     flag = TRUE;
551                     no_mdrv = pcdi->cd_ldcnt;
552                     if (no_mdrv > 1 || pcdi->ld_slave != -1) {
553                         is_mirr = TRUE;
554                         strcpy(hrec, "RAID-1");
555                     } else if (pcdi->ld_dtype == 0) {
556                         strcpy(hrec, "Disk");
557                     } else if (pcdi->ld_dtype == 1) {
558                         strcpy(hrec, "RAID-0");
559                     } else if (pcdi->ld_dtype == 2) {
560                         strcpy(hrec, "Chain");
561                     } else {
562                         strcpy(hrec, "???");
563                     }
564                     size = sprintf(buffer+len,
565                                    " Capacity [MB]:\t%-6d    \tType:          \t%s\n",
566                                    pcdi->ld_blkcnt/(1024*1024/pcdi->ld_blksize),
567                                    hrec);
568                     len += size;  pos = begin + len;
569                 } else {
570                     size = sprintf(buffer+len,
571                                    " Slave Number: \t%-2d        \tStatus:        \t%s\n",
572                                    drv_no & 0x7fff, hrec);
573                     len += size;  pos = begin + len;
574                 }
575                 drv_no = pcdi->ld_slave;
576                 if (pos < offset) {
577                     len = 0;
578                     begin = pos;
579                 }
580                 if (pos > offset + length)
581                     goto stop_output;
582             } while (drv_no != -1);
583              
584             if (is_mirr) {
585                 size = sprintf(buffer+len,
586                                " Missing Drv.: \t%-2d        \tInvalid Drv.:  \t%d\n",
587                                no_mdrv - j - k, k);
588                 len += size;  pos = begin + len;
589             }
590               
591             if (!ha->hdr[i].is_arraydrv)
592                 strcpy(hrec, "--");
593             else
594                 sprintf(hrec, "%d", ha->hdr[i].master_no);
595             size = sprintf(buffer+len,
596                            " To Array Drv.:\t%s\n", hrec);
597             len += size;  pos = begin + len;
598             if (pos < offset) {
599                 len = 0;
600                 begin = pos;
601             }
602             if (pos > offset + length)
603                 goto stop_output;
604         }       
605         gdth_ioctl_free(hanum, GDTH_SCRATCH, buf, paddr);
606         
607         if (!flag) {
608             size = sprintf(buffer+len, "\n --\n");
609             len += size;  pos = begin + len;
610         }   
611
612         /* 4. about array drives */
613         size = sprintf(buffer+len,"\nArray Drives:");
614         len += size;  pos = begin + len;
615         flag = FALSE;
616
617         buf = gdth_ioctl_alloc(hanum, GDTH_SCRATCH, FALSE, &paddr);
618         if (!buf) 
619             goto stop_output;
620         for (i = 0; i < MAX_LDRIVES; ++i) {
621             if (!(ha->hdr[i].is_arraydrv && ha->hdr[i].is_master))
622                 continue;
623             /* 4.a array drive info */
624             TRACE2(("array_info() drive no %d\n",i));
625             pai = (gdth_arrayinf_str *)buf;
626             gdtcmd->Service = CACHESERVICE;
627             gdtcmd->OpCode = GDT_IOCTL;
628             gdtcmd->u.ioctl.p_param = paddr;
629             gdtcmd->u.ioctl.param_size = sizeof(gdth_arrayinf_str);
630             gdtcmd->u.ioctl.subfunc = ARRAY_INFO | LA_CTRL_PATTERN;
631             gdtcmd->u.ioctl.channel = i;
632 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
633             gdth_do_req(scp, gdtcmd, cmnd, 30);
634             if (scp->sr_command->SCp.Status == S_OK) 
635 #else
636             gdth_do_cmd(scp, gdtcmd, cmnd, 30);
637             if (scp->SCp.Status == S_OK) 
638 #endif
639             {
640                 if (pai->ai_state == 0)
641                     strcpy(hrec, "idle");
642                 else if (pai->ai_state == 2)
643                     strcpy(hrec, "build");
644                 else if (pai->ai_state == 4)
645                     strcpy(hrec, "ready");
646                 else if (pai->ai_state == 6)
647                     strcpy(hrec, "fail");
648                 else if (pai->ai_state == 8 || pai->ai_state == 10)
649                     strcpy(hrec, "rebuild");
650                 else
651                     strcpy(hrec, "error");
652                 if (pai->ai_ext_state & 0x10)
653                     strcat(hrec, "/expand");
654                 else if (pai->ai_ext_state & 0x1)
655                     strcat(hrec, "/patch");
656                 size = sprintf(buffer+len,
657                                "\n Number:       \t%-2d        \tStatus:        \t%s\n",
658                                i,hrec);
659                 len += size;  pos = begin + len;
660                 flag = TRUE;
661
662                 if (pai->ai_type == 0)
663                     strcpy(hrec, "RAID-0");
664                 else if (pai->ai_type == 4)
665                     strcpy(hrec, "RAID-4");
666                 else if (pai->ai_type == 5)
667                     strcpy(hrec, "RAID-5");
668                 else 
669                     strcpy(hrec, "RAID-10");
670                 size = sprintf(buffer+len,
671                                " Capacity [MB]:\t%-6d    \tType:          \t%s\n",
672                                pai->ai_size/(1024*1024/pai->ai_secsize),
673                                hrec);
674                 len += size;  pos = begin + len;
675                 if (pos < offset) {
676                     len = 0;
677                     begin = pos;
678                 }
679                 if (pos > offset + length)
680                     goto stop_output;
681             }
682         }
683         gdth_ioctl_free(hanum, GDTH_SCRATCH, buf, paddr);
684         
685         if (!flag) {
686             size = sprintf(buffer+len, "\n --\n");
687             len += size;  pos = begin + len;
688         }
689
690         /* 5. about host drives */
691         size = sprintf(buffer+len,"\nHost Drives:");
692         len += size;  pos = begin + len;
693         flag = FALSE;
694
695         buf = gdth_ioctl_alloc(hanum, sizeof(gdth_hget_str), FALSE, &paddr);
696         if (!buf) 
697             goto stop_output;
698         for (i = 0; i < MAX_LDRIVES; ++i) {
699             if (!ha->hdr[i].is_logdrv || 
700                 (ha->hdr[i].is_arraydrv && !ha->hdr[i].is_master))
701                 continue;
702             /* 5.a get host drive list */
703             TRACE2(("host_get() drv_no %d\n",i));           
704             phg = (gdth_hget_str *)buf;
705             gdtcmd->Service = CACHESERVICE;
706             gdtcmd->OpCode = GDT_IOCTL;
707             gdtcmd->u.ioctl.p_param = paddr;
708             gdtcmd->u.ioctl.param_size = sizeof(gdth_hget_str);
709             gdtcmd->u.ioctl.subfunc = HOST_GET | LA_CTRL_PATTERN;
710             gdtcmd->u.ioctl.channel = i;
711             phg->entries = MAX_HDRIVES;
712             phg->offset = GDTOFFSOF(gdth_hget_str, entry[0]); 
713 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
714             gdth_do_req(scp, gdtcmd, cmnd, 30);
715             if (scp->sr_command->SCp.Status != S_OK) 
716 #else
717             gdth_do_cmd(scp, gdtcmd, cmnd, 30);
718             if (scp->SCp.Status != S_OK) 
719 #endif
720             {
721                 ha->hdr[i].ldr_no = i;
722                 ha->hdr[i].rw_attribs = 0;
723                 ha->hdr[i].start_sec = 0;
724             } else {
725                 for (j = 0; j < phg->entries; ++j) {
726                     k = phg->entry[j].host_drive;
727                     if (k >= MAX_LDRIVES)
728                         continue;
729                     ha->hdr[k].ldr_no = phg->entry[j].log_drive;
730                     ha->hdr[k].rw_attribs = phg->entry[j].rw_attribs;
731                     ha->hdr[k].start_sec = phg->entry[j].start_sec;
732                 }
733             }
734         }
735         gdth_ioctl_free(hanum, sizeof(gdth_hget_str), buf, paddr);
736
737         for (i = 0; i < MAX_HDRIVES; ++i) {
738             if (!(ha->hdr[i].present))
739                 continue;
740               
741             size = sprintf(buffer+len,
742                            "\n Number:       \t%-2d        \tArr/Log. Drive:\t%d\n",
743                            i, ha->hdr[i].ldr_no);
744             len += size;  pos = begin + len;
745             flag = TRUE;
746
747             size = sprintf(buffer+len,
748                            " Capacity [MB]:\t%-6d    \tStart Sector:  \t%d\n",
749                            (ulong32)(ha->hdr[i].size/2048), ha->hdr[i].start_sec);
750             len += size;  pos = begin + len;
751             if (pos < offset) {
752                 len = 0;
753                 begin = pos;
754             }
755             if (pos > offset + length)
756                 goto stop_output;
757         }
758         
759         if (!flag) {
760             size = sprintf(buffer+len, "\n --\n");
761             len += size;  pos = begin + len;
762         }
763     }
764
765     /* controller events */
766     size = sprintf(buffer+len,"\nController Events:\n");
767     len += size;  pos = begin + len;
768
769     for (id = -1;;) {
770         id = gdth_read_event(ha, id, estr);
771         if (estr->event_source == 0)
772             break;
773         if (estr->event_data.eu.driver.ionode == hanum &&
774             estr->event_source == ES_ASYNC) { 
775             gdth_log_event(&estr->event_data, hrec);
776             do_gettimeofday(&tv);
777             sec = (int)(tv.tv_sec - estr->first_stamp);
778             if (sec < 0) sec = 0;
779             size = sprintf(buffer+len," date- %02d:%02d:%02d\t%s\n",
780                            sec/3600, sec%3600/60, sec%60, hrec);
781             len += size;  pos = begin + len;
782             if (pos < offset) {
783                 len = 0;
784                 begin = pos;
785             }
786             if (pos > offset + length)
787                 goto stop_output;
788         }
789         if (id == -1)
790             break;
791     }
792
793 stop_output:
794 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
795     scsi_release_request(scp);
796     scsi_free_host_dev(sdev);
797 #else
798     scsi_release_command(scp);
799     scsi_free_host_dev(sdev);
800 #endif
801     *start = buffer +(offset-begin);
802     len -= (offset-begin);
803     if (len > length)
804         len = length;
805     TRACE2(("get_info() len %d pos %d begin %d offset %d length %d size %d\n",
806             len,(int)pos,(int)begin,(int)offset,length,size));
807     rc = len;
808
809 free_fail:
810     kfree(gdtcmd);
811     kfree(estr);
812     return rc;
813 }
814
815
816 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
817 static void gdth_do_req(Scsi_Request *scp, gdth_cmd_str *gdtcmd, 
818                         char *cmnd, int timeout)
819 {
820     unsigned bufflen;
821     DECLARE_COMPLETION(wait);
822
823     TRACE2(("gdth_do_req()\n"));
824     if (gdtcmd != NULL) { 
825         bufflen = sizeof(gdth_cmd_str);
826     } else {
827         bufflen = 0;
828     }
829     scp->sr_request->rq_status = RQ_SCSI_BUSY;
830     scp->sr_request->waiting = &wait;
831     scsi_do_req(scp, cmnd, gdtcmd, bufflen, gdth_scsi_done, timeout*HZ, 1);
832     wait_for_completion(&wait);
833 }
834
835 #else
836 static void gdth_do_cmd(Scsi_Cmnd *scp, gdth_cmd_str *gdtcmd, 
837                         char *cmnd, int timeout)
838 {
839     unsigned bufflen;
840     DECLARE_COMPLETION(wait);
841
842     TRACE2(("gdth_do_cmd()\n"));
843     if (gdtcmd != NULL) { 
844         scp->SCp.this_residual = IOCTL_PRI;
845         bufflen = sizeof(gdth_cmd_str);
846     } else {
847         scp->SCp.this_residual = DEFAULT_PRI;
848         bufflen = 0;
849     }
850
851     scp->request.rq_status = RQ_SCSI_BUSY;
852     scp->request.waiting = &wait;
853     scsi_do_cmd(scp, cmnd, gdtcmd, bufflen, gdth_scsi_done, timeout*HZ, 1);
854     wait_for_completion(&wait);
855 }
856 #endif
857
858 void gdth_scsi_done(Scsi_Cmnd *scp)
859 {
860     TRACE2(("gdth_scsi_done()\n"));
861
862 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
863     scp->request->rq_status = RQ_SCSI_DONE;
864     if (scp->request->waiting != NULL)
865         complete(scp->request->waiting);
866 #else
867     scp->request.rq_status = RQ_SCSI_DONE;
868     if (scp->request.waiting != NULL)
869         complete(scp->request.waiting);
870 #endif
871 }
872
873 static char *gdth_ioctl_alloc(int hanum, int size, int scratch, 
874                               ulong64 *paddr)
875 {
876     gdth_ha_str *ha;
877     ulong flags;
878     char *ret_val;
879
880     if (size == 0)
881         return NULL;
882
883     ha = HADATA(gdth_ctr_tab[hanum]);
884     spin_lock_irqsave(&ha->smp_lock, flags);
885
886     if (!ha->scratch_busy && size <= GDTH_SCRATCH) {
887         ha->scratch_busy = TRUE;
888         ret_val = ha->pscratch;
889         *paddr = ha->scratch_phys;
890     } else if (scratch) {
891         ret_val = NULL;
892     } else {
893         dma_addr_t dma_addr;
894
895         ret_val = pci_alloc_consistent(ha->pdev, size, &dma_addr);
896         *paddr = dma_addr;
897     }
898
899     spin_unlock_irqrestore(&ha->smp_lock, flags);
900     return ret_val;
901 }
902
903 static void gdth_ioctl_free(int hanum, int size, char *buf, ulong64 paddr)
904 {
905     gdth_ha_str *ha;
906     ulong flags;
907
908     ha = HADATA(gdth_ctr_tab[hanum]);
909     spin_lock_irqsave(&ha->smp_lock, flags);
910
911     if (buf == ha->pscratch) {
912         ha->scratch_busy = FALSE;
913     } else {
914         pci_free_consistent(ha->pdev, size, buf, paddr);
915     }
916
917     spin_unlock_irqrestore(&ha->smp_lock, flags);
918 }
919
920 #ifdef GDTH_IOCTL_PROC
921 static int gdth_ioctl_check_bin(int hanum, ushort size)
922 {
923     gdth_ha_str *ha;
924     ulong flags;
925     int ret_val;
926
927     ha = HADATA(gdth_ctr_tab[hanum]);
928     spin_lock_irqsave(&ha->smp_lock, flags);
929
930     ret_val = FALSE;
931     if (ha->scratch_busy) {
932         if (((gdth_iord_str *)ha->pscratch)->size == (ulong32)size)
933             ret_val = TRUE;
934     }
935     spin_unlock_irqrestore(&ha->smp_lock, flags);
936     return ret_val;
937 }
938 #endif
939
940 static void gdth_wait_completion(int hanum, int busnum, int id)
941 {
942     gdth_ha_str *ha;
943     ulong flags;
944     int i;
945     Scsi_Cmnd *scp;
946     unchar b, t;
947
948     ha = HADATA(gdth_ctr_tab[hanum]);
949     spin_lock_irqsave(&ha->smp_lock, flags);
950
951     for (i = 0; i < GDTH_MAXCMDS; ++i) {
952         scp = ha->cmd_tab[i].cmnd;
953
954         b = virt_ctr ? NUMDATA(scp->device->host)->busnum : scp->device->channel;
955         t = scp->device->id;
956         if (!SPECIAL_SCP(scp) && t == (unchar)id && 
957             b == (unchar)busnum) {
958             scp->SCp.have_data_in = 0;
959             spin_unlock_irqrestore(&ha->smp_lock, flags);
960             while (!scp->SCp.have_data_in)
961                 barrier();
962             spin_lock_irqsave(&ha->smp_lock, flags);
963         }
964     }
965     spin_unlock_irqrestore(&ha->smp_lock, flags);
966 }
967
968 static void gdth_stop_timeout(int hanum, int busnum, int id)
969 {
970     gdth_ha_str *ha;
971     ulong flags;
972     Scsi_Cmnd *scp;
973     unchar b, t;
974
975     ha = HADATA(gdth_ctr_tab[hanum]);
976     spin_lock_irqsave(&ha->smp_lock, flags);
977
978     for (scp = ha->req_first; scp; scp = (Scsi_Cmnd *)scp->SCp.ptr) {
979         b = virt_ctr ? NUMDATA(scp->device->host)->busnum : scp->device->channel;
980         t = scp->device->id;
981         if (t == (unchar)id && b == (unchar)busnum) {
982             TRACE2(("gdth_stop_timeout(): update_timeout()\n"));
983             scp->SCp.buffers_residual = gdth_update_timeout(hanum, scp, 0);
984         }
985     }
986     spin_unlock_irqrestore(&ha->smp_lock, flags);
987 }
988
989 static void gdth_start_timeout(int hanum, int busnum, int id)
990 {
991     gdth_ha_str *ha;
992     ulong flags;
993     Scsi_Cmnd *scp;
994     unchar b, t;
995
996     ha = HADATA(gdth_ctr_tab[hanum]);
997     spin_lock_irqsave(&ha->smp_lock, flags);
998
999     for (scp = ha->req_first; scp; scp = (Scsi_Cmnd *)scp->SCp.ptr) {
1000         b = virt_ctr ? NUMDATA(scp->device->host)->busnum : scp->device->channel;
1001         t = scp->device->id;
1002         if (t == (unchar)id && b == (unchar)busnum) {
1003             TRACE2(("gdth_start_timeout(): update_timeout()\n"));
1004             gdth_update_timeout(hanum, scp, scp->SCp.buffers_residual);
1005         }
1006     }
1007     spin_unlock_irqrestore(&ha->smp_lock, flags);
1008 }
1009
1010 static int gdth_update_timeout(int hanum, Scsi_Cmnd *scp, int timeout)
1011 {
1012     int oldto;
1013
1014     oldto = scp->timeout_per_command;
1015     scp->timeout_per_command = timeout;
1016
1017     if (timeout == 0) {
1018         del_timer(&scp->eh_timeout);
1019         scp->eh_timeout.data = (unsigned long) NULL;
1020         scp->eh_timeout.expires = 0;
1021     } else {
1022         if (scp->eh_timeout.data != (unsigned long) NULL) 
1023             del_timer(&scp->eh_timeout);
1024         scp->eh_timeout.data = (unsigned long) scp;
1025         scp->eh_timeout.expires = jiffies + timeout;
1026         add_timer(&scp->eh_timeout);
1027     }
1028
1029     return oldto;
1030 }