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