]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - drivers/scsi/gdth.c
projects / mirror_ubuntu-hirsute-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
UBUNTU: Ubuntu-5.11.0-22.23
[mirror_ubuntu-hirsute-kernel.git] / drivers / scsi / gdth.c
CommitLineData
db73570c 1// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4
LT		 2/************************************************************************
3 * Linux driver for *
31481455 4 * ICP vortex GmbH: GDT PCI Disk Array Controllers *
1da177e4
LT		 5 * Intel Corporation: Storage RAID Controllers *
6 * *
7 * gdth.c *
cbd5f69b 8 * Copyright (C) 1995-06 ICP vortex GmbH, Achim Leubner *
1da177e4 9 * Copyright (C) 2002-04 Intel Corporation *
cbd5f69b 10 * Copyright (C) 2003-06 Adaptec Inc. *
1da177e4
LT		 11 * <achim_leubner@adaptec.com> *
12 * *
13 * Additions/Fixes: *
14 * Boji Tony Kannanthanam <boji.t.kannanthanam@intel.com> *
15 * Johannes Dinner <johannes_dinner@adaptec.com> *
16 * *
1da177e4 17 * *
8d7a5da4 18 * Linux kernel 2.6.x supported *
1da177e4 19 * *
1da177e4
LT		 20 ************************************************************************/
21
22/* All GDT Disk Array Controllers are fully supported by this driver.
31481455 23 * This includes the PCI SCSI Disk Array Controllers and the
1da177e4
LT		 24 * PCI Fibre Channel Disk Array Controllers. See gdth.h for a complete
25 * list of all controller types.
26 *
1da177e4
LT		 27 * After the optional list of IRQ values, other possible
28 * command line options are:
29 * disable:Y disable driver
30 * disable:N enable driver
31 * reserve_mode:0 reserve no drives for the raw service
32 * reserve_mode:1 reserve all not init., removable drives
33 * reserve_mode:2 reserve all not init. drives
34 * reserve_list:h,b,t,l,h,b,t,l,... reserve particular drive(s) with
35 * h- controller no., b- channel no.,
36 * t- target ID, l- LUN
37 * reverse_scan:Y reverse scan order for PCI controllers
38 * reverse_scan:N scan PCI controllers like BIOS
39 * max_ids:x x - target ID count per channel (1..MAXID)
40 * rescan:Y rescan all channels/IDs
41 * rescan:N use all devices found until now
1da177e4
LT		 42 * hdr_channel:x x - number of virtual bus for host drives
43 * shared_access:Y disable driver reserve/release protocol to
44 * access a shared resource from several nodes,
575c9687 45 * appropriate controller firmware required
1da177e4 46 * shared_access:N enable driver reserve/release protocol
1da177e4
LT		 47 * force_dma32:Y use only 32 bit DMA mode
48 * force_dma32:N use 64 bit DMA mode, if supported
49 *
50 * The default values are: "gdth=disable:N,reserve_mode:1,reverse_scan:N,
52759e6a 51 * max_ids:127,rescan:N,hdr_channel:0,
31481455 52 * shared_access:Y,force_dma32:N".
1da177e4
LT		 53 * Here is another example: "gdth=reserve_list:0,1,2,0,0,1,3,0,rescan:Y".
54 *
55 * When loading the gdth driver as a module, the same options are available.
56 * You can set the IRQs with "IRQ=...". However, the syntax to specify the
57 * options changes slightly. You must replace all ',' between options
58 * with ' ' and all ':' with '=' and you must use
59 * '1' in place of 'Y' and '0' in place of 'N'.
60 *
61 * Default: "modprobe gdth disable=0 reserve_mode=1 reverse_scan=0
52759e6a 62 * max_ids=127 rescan=0 hdr_channel=0 shared_access=0
31481455 63 * force_dma32=0"
1da177e4
LT		 64 * The other example: "modprobe gdth reserve_list=0,1,2,0,0,1,3,0 rescan=1".
65 */
66
67/* The meaning of the Scsi_Pointer members in this driver is as follows:
68 * ptr: Chaining
d35055a0
BH		 69 * this_residual: unused
70 * buffer: unused
3892d88a 71 * dma_handle: unused
d35055a0 72 * buffers_residual: unused
3892d88a 73 * Status: unused
f842b64e
BH		 74 * Message: unused
75 * have_data_in: unused
76 * sent_command: unused
77 * phase: unused
1da177e4
LT		 78 */
79
1da177e4
LT		 80/* statistics */
81#define GDTH_STATISTICS
82
83#include <linux/module.h>
84
85#include <linux/version.h>
86#include <linux/kernel.h>
87#include <linux/types.h>
88#include <linux/pci.h>
89#include <linux/string.h>
90#include <linux/ctype.h>
91#include <linux/ioport.h>
92#include <linux/delay.h>
1da177e4
LT		 93#include <linux/interrupt.h>
94#include <linux/in.h>
95#include <linux/proc_fs.h>
96#include <linux/time.h>
97#include <linux/timer.h>
910638ae 98#include <linux/dma-mapping.h>
835cc24a 99#include <linux/list.h>
c45d15d2 100#include <linux/mutex.h>
5a0e3ad6 101#include <linux/slab.h>
1da177e4
LT		 102#include <linux/reboot.h>
103
104#include <asm/dma.h>
1da177e4 105#include <asm/io.h>
7c0f6ba6 106#include <linux/uaccess.h>
1da177e4 107#include <linux/spinlock.h>
1da177e4 108#include <linux/blkdev.h>
3892d88a 109#include <linux/scatterlist.h>
1da177e4
LT		 110
111#include "scsi.h"
112#include <scsi/scsi_host.h>
cbd5f69b 113#include "gdth.h"
1da177e4 114
c45d15d2 115static DEFINE_MUTEX(gdth_mutex);
1da177e4 116static void gdth_delay(int milliseconds);
1fe6dbf4 117static void gdth_eval_mapping(u32 size, u32 *cyls, int *heads, int *secs);
7d12e780 118static irqreturn_t gdth_interrupt(int irq, void *dev_id);
230e886e 119static irqreturn_t __gdth_interrupt(gdth_ha_str *ha,
10e1b4bc 120 int gdth_from_wait, int* pIndex);
1fe6dbf4 121static int gdth_sync_event(gdth_ha_str *ha, int service, u8 index,
91ebc1fa 122 struct scsi_cmnd *scp);
45f1a41b 123static int gdth_async_event(gdth_ha_str *ha);
1da177e4
LT		 124static void gdth_log_event(gdth_evt_data *dvr, char *buffer);
125
91ebc1fa 126static void gdth_putq(gdth_ha_str *ha, struct scsi_cmnd *scp, u8 priority);
45f1a41b 127static void gdth_next(gdth_ha_str *ha);
91ebc1fa
JT		 128static int gdth_fill_raw_cmd(gdth_ha_str *ha, struct scsi_cmnd *scp, u8 b);
129static int gdth_special_cmd(gdth_ha_str *ha, struct scsi_cmnd *scp);
1fe6dbf4
DJ		 130static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, u16 source,
131 u16 idx, gdth_evt_data *evt);
1da177e4 132static int gdth_read_event(gdth_ha_str *ha, int handle, gdth_evt_str *estr);
1fe6dbf4 133static void gdth_readapp_event(gdth_ha_str *ha, u8 application,
1da177e4
LT		 134 gdth_evt_str *estr);
135static void gdth_clear_events(void);
136
91ebc1fa 137static void gdth_copy_internal_data(gdth_ha_str *ha, struct scsi_cmnd *scp,
1fe6dbf4 138 char *buffer, u16 count);
91ebc1fa
JT		 139static int gdth_internal_cache_cmd(gdth_ha_str *ha, struct scsi_cmnd *scp);
140static int gdth_fill_cache_cmd(gdth_ha_str *ha, struct scsi_cmnd *scp,
141 u16 hdrive);
1da177e4 142
45f1a41b 143static void gdth_enable_int(gdth_ha_str *ha);
45f1a41b
BH		 144static int gdth_test_busy(gdth_ha_str *ha);
145static int gdth_get_cmd_index(gdth_ha_str *ha);
146static void gdth_release_event(gdth_ha_str *ha);
1fe6dbf4
DJ		 147static int gdth_wait(gdth_ha_str *ha, int index,u32 time);
148static int gdth_internal_cmd(gdth_ha_str *ha, u8 service, u16 opcode,
149 u32 p1, u64 p2,u64 p3);
45f1a41b 150static int gdth_search_drives(gdth_ha_str *ha);
1fe6dbf4 151static int gdth_analyse_hdrive(gdth_ha_str *ha, u16 hdrive);
1da177e4 152
45f1a41b 153static const char *gdth_ctr_name(gdth_ha_str *ha);
1da177e4
LT		 154
155static int gdth_open(struct inode *inode, struct file *filep);
156static int gdth_close(struct inode *inode, struct file *filep);
f4927c45
AB		 157static long gdth_unlocked_ioctl(struct file *filep, unsigned int cmd,
158 unsigned long arg);
1da177e4 159
45f1a41b 160static void gdth_flush(gdth_ha_str *ha);
f281233d 161static int gdth_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmd);
3058d5de
BH		 162static int __gdth_queuecommand(gdth_ha_str *ha, struct scsi_cmnd *scp,
163 struct gdth_cmndinfo *cmndinfo);
cbd5f69b 164static void gdth_scsi_done(struct scsi_cmnd *scp);
1da177e4
LT		 165
166#ifdef DEBUG_GDTH
1fe6dbf4 167static u8 DebugState = DEBUG_GDTH;
1da177e4
LT		 168#define TRACE(a) {if (DebugState==1) {printk a;}}
169#define TRACE2(a) {if (DebugState==1 || DebugState==2) {printk a;}}
170#define TRACE3(a) {if (DebugState!=0) {printk a;}}
1da177e4
LT		 171#else /* !DEBUG */
172#define TRACE(a)
173#define TRACE2(a)
174#define TRACE3(a)
175#endif
176
177#ifdef GDTH_STATISTICS
1fe6dbf4 178static u32 max_rq=0, max_index=0, max_sg=0;
1fe6dbf4 179static u32 act_ints=0, act_ios=0, act_stats=0, act_rq=0;
1da177e4
LT		 180static struct timer_list gdth_timer;
181#endif
182
1fe6dbf4 183#define PTR2USHORT(a) (u16)(unsigned long)(a)
6391a113
TK		 184#define GDTOFFSOF(a,b) (size_t)&(((a*)0)->b)
185#define INDEX_OK(i,t) ((i)<ARRAY_SIZE(t))
1da177e4 186
1da177e4
LT		 187#define BUS_L2P(a,b) ((b)>(a)->virt_bus ? (b-1):(b))
188
1fe6dbf4 189static u8 gdth_polling; /* polling if TRUE */
1da177e4 190static int gdth_ctr_count = 0; /* controller count */
884f7fba 191static LIST_HEAD(gdth_instances); /* controller list */
1fe6dbf4 192static u8 gdth_write_through = FALSE; /* write through */
1da177e4
LT		 193static gdth_evt_str ebuffer[MAX_EVENTS]; /* event buffer */
194static int elastidx;
195static int eoldidx;
196static int major;
197
198#define DIN 1 /* IN data direction */
199#define DOU 2 /* OUT data direction */
200#define DNO DIN /* no data transfer */
201#define DUN DIN /* unknown data direction */
1fe6dbf4 202static u8 gdth_direction_tab[0x100] = {
1da177e4
LT		 203 DNO,DNO,DIN,DIN,DOU,DIN,DIN,DOU,DIN,DUN,DOU,DOU,DUN,DUN,DUN,DIN,
204 DNO,DIN,DIN,DOU,DIN,DOU,DNO,DNO,DOU,DNO,DIN,DNO,DIN,DOU,DNO,DUN,
205 DIN,DUN,DIN,DUN,DOU,DIN,DUN,DUN,DIN,DIN,DOU,DNO,DUN,DIN,DOU,DOU,
206 DOU,DOU,DOU,DNO,DIN,DNO,DNO,DIN,DOU,DOU,DOU,DOU,DIN,DOU,DIN,DOU,
207 DOU,DOU,DIN,DIN,DIN,DNO,DUN,DNO,DNO,DNO,DUN,DNO,DOU,DIN,DUN,DUN,
208 DUN,DUN,DUN,DUN,DUN,DOU,DUN,DUN,DUN,DUN,DIN,DUN,DUN,DUN,DUN,DUN,
209 DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,
210 DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,
211 DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DIN,DUN,DOU,DUN,DUN,DUN,DUN,DUN,
212 DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DIN,DUN,
213 DUN,DUN,DUN,DUN,DUN,DNO,DNO,DUN,DIN,DNO,DOU,DUN,DNO,DUN,DOU,DOU,
214 DOU,DOU,DOU,DNO,DUN,DIN,DOU,DIN,DIN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,
215 DUN,DUN,DOU,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,
216 DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,
217 DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DOU,DUN,DUN,DUN,DUN,DUN,
218 DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN
219};
220
221/* LILO and modprobe/insmod parameters */
1da177e4
LT		 222/* disable driver flag */
223static int disable __initdata = 0;
224/* reserve flag */
225static int reserve_mode = 1;
226/* reserve list */
227static int reserve_list[MAX_RES_ARGS] =
228{0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
229 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
230 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
231/* scan order for PCI controllers */
232static int reverse_scan = 0;
233/* virtual channel for the host drives */
234static int hdr_channel = 0;
235/* max. IDs per channel */
236static int max_ids = MAXID;
237/* rescan all IDs */
238static int rescan = 0;
1da177e4
LT		 239/* shared access */
240static int shared_access = 1;
1da177e4
LT		 241/* 64 bit DMA mode, support for drives > 2 TB, if force_dma32 = 0 */
242static int force_dma32 = 0;
243
244/* parameters for modprobe/insmod */
1da177e4
LT		 245module_param(disable, int, 0);
246module_param(reserve_mode, int, 0);
247module_param_array(reserve_list, int, NULL, 0);
248module_param(reverse_scan, int, 0);
249module_param(hdr_channel, int, 0);
250module_param(max_ids, int, 0);
251module_param(rescan, int, 0);
1da177e4 252module_param(shared_access, int, 0);
1da177e4
LT		 253module_param(force_dma32, int, 0);
254MODULE_AUTHOR("Achim Leubner");
255MODULE_LICENSE("GPL");
256
257/* ioctl interface */
00977a59 258static const struct file_operations gdth_fops = {
f4927c45 259 .unlocked_ioctl = gdth_unlocked_ioctl,
1da177e4
LT		 260 .open = gdth_open,
261 .release = gdth_close,
6038f373 262 .llseek = noop_llseek,
1da177e4
LT		 263};
264
265#include "gdth_proc.h"
266#include "gdth_proc.c"
267
884f7fba
BH		 268static gdth_ha_str *gdth_find_ha(int hanum)
269{
270 gdth_ha_str *ha;
271
272 list_for_each_entry(ha, &gdth_instances, list)
273 if (hanum == ha->hanum)
274 return ha;
275
276 return NULL;
277}
278
3058d5de
BH		 279static struct gdth_cmndinfo *gdth_get_cmndinfo(gdth_ha_str *ha)
280{
281 struct gdth_cmndinfo *priv = NULL;
1fe6dbf4 282 unsigned long flags;
3058d5de
BH		 283 int i;
284
285 spin_lock_irqsave(&ha->smp_lock, flags);
286
287 for (i=0; i<GDTH_MAXCMDS; ++i) {
288 if (ha->cmndinfo[i].index == 0) {
289 priv = &ha->cmndinfo[i];
3058d5de 290 memset(priv, 0, sizeof(*priv));
ee54cc6a 291 priv->index = i+1;
3058d5de
BH		 292 break;
293 }
294 }
295
296 spin_unlock_irqrestore(&ha->smp_lock, flags);
297
298 return priv;
299}
300
301static void gdth_put_cmndinfo(struct gdth_cmndinfo *priv)
302{
303 BUG_ON(!priv);
304 priv->index = 0;
305}
306
1da177e4
LT		 307static void gdth_delay(int milliseconds)
308{
309 if (milliseconds == 0) {
310 udelay(1);
311 } else {
312 mdelay(milliseconds);
313 }
314}
315
cbd5f69b
LA		 316static void gdth_scsi_done(struct scsi_cmnd *scp)
317{
3058d5de
BH		 318 struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
319 int internal_command = cmndinfo->internal_command;
320
b8bff2ae 321 TRACE2(("gdth_scsi_done()\n"));
cbd5f69b 322
3058d5de
BH		 323 gdth_put_cmndinfo(cmndinfo);
324 scp->host_scribble = NULL;
325
326 if (internal_command)
b8bff2ae
MW		 327 complete((struct completion *)scp->request);
328 else
329 scp->scsi_done(scp);
cbd5f69b
LA		 330}
331
78e8df28
WH		 332static int __gdth_execute(struct scsi_device *sdev, gdth_cmd_str *gdtcmd,
333 char *cmnd, int timeout, u32 *info)
cbd5f69b 334{
3058d5de 335 gdth_ha_str *ha = shost_priv(sdev->host);
91ebc1fa 336 struct scsi_cmnd *scp;
3058d5de 337 struct gdth_cmndinfo cmndinfo;
6e9a4738 338 DECLARE_COMPLETION_ONSTACK(wait);
cbd5f69b
LA		 339 int rval;
340
bbfbbbc1 341 scp = kzalloc(sizeof(*scp), GFP_KERNEL);
cbd5f69b
LA		 342 if (!scp)
343 return -ENOMEM;
bbfbbbc1 344
1b96f895
SS		 345 scp->sense_buffer = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_KERNEL);
346 if (!scp->sense_buffer) {
347 kfree(scp);
348 return -ENOMEM;
349 }
350
cbd5f69b 351 scp->device = sdev;
3058d5de
BH		 352 memset(&cmndinfo, 0, sizeof(cmndinfo));
353
beb40487
CH		 354 /* use request field to save the ptr. to completion struct. */
355 scp->request = (struct request *)&wait;
cbd5f69b 356 scp->cmd_len = 12;
64a87b24 357 scp->cmnd = cmnd;
f842b64e 358 cmndinfo.priority = IOCTL_PRI;
ee54cc6a 359 cmndinfo.internal_cmd_str = gdtcmd;
3058d5de
BH		 360 cmndinfo.internal_command = 1;
361
362 TRACE(("__gdth_execute() cmd 0x%x\n", scp->cmnd[0]));
363 __gdth_queuecommand(ha, scp, &cmndinfo);
364
cbd5f69b
LA		 365 wait_for_completion(&wait);
366
f842b64e 367 rval = cmndinfo.status;
cbd5f69b 368 if (info)
f842b64e 369 *info = cmndinfo.info;
1b96f895 370 kfree(scp->sense_buffer);
cbd5f69b
LA		 371 kfree(scp);
372 return rval;
373}
cbd5f69b
LA		 374
375int gdth_execute(struct Scsi_Host *shost, gdth_cmd_str *gdtcmd, char *cmnd,
376 int timeout, u32 *info)
377{
378 struct scsi_device *sdev = scsi_get_host_dev(shost);
379 int rval = __gdth_execute(sdev, gdtcmd, cmnd, timeout, info);
380
381 scsi_free_host_dev(sdev);
382 return rval;
383}
384
1fe6dbf4 385static void gdth_eval_mapping(u32 size, u32 *cyls, int *heads, int *secs)
1da177e4
LT		 386{
387 *cyls = size /HEADS/SECS;
388 if (*cyls <= MAXCYLS) {
389 *heads = HEADS;
390 *secs = SECS;
391 } else { /* too high for 64*32 */
392 *cyls = size /MEDHEADS/MEDSECS;
393 if (*cyls <= MAXCYLS) {
394 *heads = MEDHEADS;
395 *secs = MEDSECS;
396 } else { /* too high for 127*63 */
397 *cyls = size /BIGHEADS/BIGSECS;
398 *heads = BIGHEADS;
399 *secs = BIGSECS;
400 }
401 }
402}
403
1fe6dbf4 404static bool gdth_search_vortex(u16 device)
1da177e4 405{
cff26806
JG		 406 if (device <= PCI_DEVICE_ID_VORTEX_GDT6555)
407 return true;
408 if (device >= PCI_DEVICE_ID_VORTEX_GDT6x17RP &&
409 device <= PCI_DEVICE_ID_VORTEX_GDTMAXRP)
410 return true;
411 if (device == PCI_DEVICE_ID_VORTEX_GDTNEWRX ||
412 device == PCI_DEVICE_ID_VORTEX_GDTNEWRX2)
413 return true;
414 return false;
1da177e4
LT		 415}
416
cff26806
JG		 417static int gdth_pci_probe_one(gdth_pci_str *pcistr, gdth_ha_str **ha_out);
418static int gdth_pci_init_one(struct pci_dev *pdev,
419 const struct pci_device_id *ent);
420static void gdth_pci_remove_one(struct pci_dev *pdev);
421static void gdth_remove_one(gdth_ha_str *ha);
422
1da177e4
LT		 423/* Vortex only makes RAID controllers.
424 * We do not really want to specify all 550 ids here, so wildcard match.
425 */
cff26806
JG		 426static const struct pci_device_id gdthtable[] = {
427 { PCI_VDEVICE(VORTEX, PCI_ANY_ID) },
428 { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_SRC) },
429 { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_SRC_XSCALE) },
430 { } /* terminate list */
1da177e4 431};
cff26806 432MODULE_DEVICE_TABLE(pci, gdthtable);
1da177e4 433
cff26806
JG		 434static struct pci_driver gdth_pci_driver = {
435 .name = "gdth",
436 .id_table = gdthtable,
437 .probe = gdth_pci_init_one,
438 .remove = gdth_pci_remove_one,
439};
440
6f039790 441static void gdth_pci_remove_one(struct pci_dev *pdev)
1da177e4 442{
cff26806
JG		 443 gdth_ha_str *ha = pci_get_drvdata(pdev);
444
cff26806
JG		 445 list_del(&ha->list);
446 gdth_remove_one(ha);
447
448 pci_disable_device(pdev);
449}
450
6f039790
GKH		 451static int gdth_pci_init_one(struct pci_dev *pdev,
452 const struct pci_device_id *ent)
cff26806 453{
1fe6dbf4
DJ		 454 u16 vendor = pdev->vendor;
455 u16 device = pdev->device;
456 unsigned long base0, base1, base2;
cff26806
JG		 457 int rc;
458 gdth_pci_str gdth_pcistr;
459 gdth_ha_str *ha = NULL;
1da177e4 460
cff26806
JG		 461 TRACE(("gdth_search_dev() cnt %d vendor %x device %x\n",
462 gdth_ctr_count, vendor, device));
1da177e4 463
cff26806
JG		 464 memset(&gdth_pcistr, 0, sizeof(gdth_pcistr));
465
466 if (vendor == PCI_VENDOR_ID_VORTEX && !gdth_search_vortex(device))
467 return -ENODEV;
468
469 rc = pci_enable_device(pdev);
470 if (rc)
471 return rc;
472
473 if (gdth_ctr_count >= MAXHA)
474 return -EBUSY;
99109301 475
1da177e4 476 /* GDT PCI controller found, resources are already in pdev */
cff26806 477 gdth_pcistr.pdev = pdev;
1da177e4
LT		 478 base0 = pci_resource_flags(pdev, 0);
479 base1 = pci_resource_flags(pdev, 1);
480 base2 = pci_resource_flags(pdev, 2);
481 if (device <= PCI_DEVICE_ID_VORTEX_GDT6000B || /* GDT6000/B */
482 device >= PCI_DEVICE_ID_VORTEX_GDT6x17RP) { /* MPR */
483 if (!(base0 & IORESOURCE_MEM))
cff26806
JG		 484 return -ENODEV;
485 gdth_pcistr.dpmem = pci_resource_start(pdev, 0);
1da177e4
LT		 486 } else { /* GDT6110, GDT6120, .. */
487 if (!(base0 & IORESOURCE_MEM) ||
488 !(base2 & IORESOURCE_MEM) ||
489 !(base1 & IORESOURCE_IO))
cff26806
JG		 490 return -ENODEV;
491 gdth_pcistr.dpmem = pci_resource_start(pdev, 2);
492 gdth_pcistr.io = pci_resource_start(pdev, 1);
1da177e4
LT		 493 }
494 TRACE2(("Controller found at %d/%d, irq %d, dpmem 0x%lx\n",
cff26806
JG		 495 gdth_pcistr.pdev->bus->number,
496 PCI_SLOT(gdth_pcistr.pdev->devfn),
497 gdth_pcistr.irq,
498 gdth_pcistr.dpmem));
1da177e4 499
cff26806
JG		 500 rc = gdth_pci_probe_one(&gdth_pcistr, &ha);
501 if (rc)
502 return rc;
1da177e4 503
cff26806 504 return 0;
1da177e4 505}
1da177e4 506
6f039790
GKH		 507static int gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
508 gdth_ha_str *ha)
1da177e4
LT		 509{
510 register gdt6_dpram_str __iomem *dp6_ptr;
511 register gdt6c_dpram_str __iomem *dp6c_ptr;
512 register gdt6m_dpram_str __iomem *dp6m_ptr;
1fe6dbf4
DJ		 513 u32 retries;
514 u8 prot_ver;
515 u16 command;
1da177e4
LT		 516 int i, found = FALSE;
517
518 TRACE(("gdth_init_pci()\n"));
519
4c9c8d78 520 if (pdev->vendor == PCI_VENDOR_ID_INTEL)
1da177e4
LT		 521 ha->oem_id = OEM_ID_INTEL;
522 else
523 ha->oem_id = OEM_ID_ICP;
4c9c8d78 524 ha->brd_phys = (pdev->bus->number << 8) | (pdev->devfn & 0xf8);
1fe6dbf4 525 ha->stype = (u32)pdev->device;
4c9c8d78
JG		 526 ha->irq = pdev->irq;
527 ha->pdev = pdev;
1da177e4 528
8e9a8a0d 529 if (ha->pdev->device <= PCI_DEVICE_ID_VORTEX_GDT6000B) { /* GDT6000/B */
1da177e4
LT		 530 TRACE2(("init_pci() dpmem %lx irq %d\n",pcistr->dpmem,ha->irq));
531 ha->brd = ioremap(pcistr->dpmem, sizeof(gdt6_dpram_str));
532 if (ha->brd == NULL) {
533 printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
534 return 0;
535 }
536 /* check and reset interface area */
537 dp6_ptr = ha->brd;
a52667f3
JG		 538 writel(DPMEM_MAGIC, &dp6_ptr->u);
539 if (readl(&dp6_ptr->u) != DPMEM_MAGIC) {
1da177e4
LT		 540 printk("GDT-PCI: Cannot access DPMEM at 0x%lx (shadowed?)\n",
541 pcistr->dpmem);
542 found = FALSE;
543 for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
544 iounmap(ha->brd);
1fe6dbf4 545 ha->brd = ioremap(i, sizeof(u16));
1da177e4
LT		 546 if (ha->brd == NULL) {
547 printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
548 return 0;
549 }
a52667f3 550 if (readw(ha->brd) != 0xffff) {
1da177e4
LT		 551 TRACE2(("init_pci_old() address 0x%x busy\n", i));
552 continue;
553 }
554 iounmap(ha->brd);
4c9c8d78 555 pci_write_config_dword(pdev, PCI_BASE_ADDRESS_0, i);
1da177e4
LT		 556 ha->brd = ioremap(i, sizeof(gdt6_dpram_str));
557 if (ha->brd == NULL) {
558 printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
559 return 0;
560 }
561 dp6_ptr = ha->brd;
a52667f3
JG		 562 writel(DPMEM_MAGIC, &dp6_ptr->u);
563 if (readl(&dp6_ptr->u) == DPMEM_MAGIC) {
1da177e4
LT		 564 printk("GDT-PCI: Use free address at 0x%x\n", i);
565 found = TRUE;
566 break;
567 }
568 }
569 if (!found) {
570 printk("GDT-PCI: No free address found!\n");
571 iounmap(ha->brd);
572 return 0;
573 }
574 }
575 memset_io(&dp6_ptr->u, 0, sizeof(dp6_ptr->u));
a52667f3 576 if (readl(&dp6_ptr->u) != 0) {
1da177e4
LT		 577 printk("GDT-PCI: Initialization error (DPMEM write error)\n");
578 iounmap(ha->brd);
579 return 0;
580 }
581
582 /* disable board interrupts, deinit services */
a52667f3
JG		 583 writeb(0xff, &dp6_ptr->io.irqdel);
584 writeb(0x00, &dp6_ptr->io.irqen);
585 writeb(0x00, &dp6_ptr->u.ic.S_Status);
586 writeb(0x00, &dp6_ptr->u.ic.Cmd_Index);
587
588 writel(pcistr->dpmem, &dp6_ptr->u.ic.S_Info[0]);
589 writeb(0xff, &dp6_ptr->u.ic.S_Cmd_Indx);
590 writeb(0, &dp6_ptr->io.event);
1da177e4
LT		 591 retries = INIT_RETRIES;
592 gdth_delay(20);
a52667f3 593 while (readb(&dp6_ptr->u.ic.S_Status) != 0xff) {
1da177e4
LT		 594 if (--retries == 0) {
595 printk("GDT-PCI: Initialization error (DEINIT failed)\n");
596 iounmap(ha->brd);
597 return 0;
598 }
599 gdth_delay(1);
600 }
1fe6dbf4 601 prot_ver = (u8)readl(&dp6_ptr->u.ic.S_Info[0]);
a52667f3
JG		 602 writeb(0, &dp6_ptr->u.ic.S_Status);
603 writeb(0xff, &dp6_ptr->io.irqdel);
1da177e4
LT		 604 if (prot_ver != PROTOCOL_VERSION) {
605 printk("GDT-PCI: Illegal protocol version\n");
606 iounmap(ha->brd);
607 return 0;
608 }
609
610 ha->type = GDT_PCI;
611 ha->ic_all_size = sizeof(dp6_ptr->u);
612
613 /* special command to controller BIOS */
a52667f3
JG		 614 writel(0x00, &dp6_ptr->u.ic.S_Info[0]);
615 writel(0x00, &dp6_ptr->u.ic.S_Info[1]);
616 writel(0x00, &dp6_ptr->u.ic.S_Info[2]);
617 writel(0x00, &dp6_ptr->u.ic.S_Info[3]);
618 writeb(0xfe, &dp6_ptr->u.ic.S_Cmd_Indx);
619 writeb(0, &dp6_ptr->io.event);
1da177e4
LT		 620 retries = INIT_RETRIES;
621 gdth_delay(20);
a52667f3 622 while (readb(&dp6_ptr->u.ic.S_Status) != 0xfe) {
1da177e4
LT		 623 if (--retries == 0) {
624 printk("GDT-PCI: Initialization error\n");
625 iounmap(ha->brd);
626 return 0;
627 }
628 gdth_delay(1);
629 }
a52667f3
JG		 630 writeb(0, &dp6_ptr->u.ic.S_Status);
631 writeb(0xff, &dp6_ptr->io.irqdel);
1da177e4
LT		 632
633 ha->dma64_support = 0;
634
8e9a8a0d 635 } else if (ha->pdev->device <= PCI_DEVICE_ID_VORTEX_GDT6555) { /* GDT6110, ... */
1da177e4
LT		 636 ha->plx = (gdt6c_plx_regs *)pcistr->io;
637 TRACE2(("init_pci_new() dpmem %lx irq %d\n",
638 pcistr->dpmem,ha->irq));
639 ha->brd = ioremap(pcistr->dpmem, sizeof(gdt6c_dpram_str));
640 if (ha->brd == NULL) {
641 printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
642 iounmap(ha->brd);
643 return 0;
644 }
645 /* check and reset interface area */
646 dp6c_ptr = ha->brd;
a52667f3
JG		 647 writel(DPMEM_MAGIC, &dp6c_ptr->u);
648 if (readl(&dp6c_ptr->u) != DPMEM_MAGIC) {
1da177e4
LT		 649 printk("GDT-PCI: Cannot access DPMEM at 0x%lx (shadowed?)\n",
650 pcistr->dpmem);
651 found = FALSE;
652 for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
653 iounmap(ha->brd);
1fe6dbf4 654 ha->brd = ioremap(i, sizeof(u16));
1da177e4
LT		 655 if (ha->brd == NULL) {
656 printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
657 return 0;
658 }
a52667f3 659 if (readw(ha->brd) != 0xffff) {
1da177e4
LT		 660 TRACE2(("init_pci_plx() address 0x%x busy\n", i));
661 continue;
662 }
663 iounmap(ha->brd);
4c9c8d78 664 pci_write_config_dword(pdev, PCI_BASE_ADDRESS_2, i);
1da177e4
LT		 665 ha->brd = ioremap(i, sizeof(gdt6c_dpram_str));
666 if (ha->brd == NULL) {
667 printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
668 return 0;
669 }
670 dp6c_ptr = ha->brd;
a52667f3
JG		 671 writel(DPMEM_MAGIC, &dp6c_ptr->u);
672 if (readl(&dp6c_ptr->u) == DPMEM_MAGIC) {
1da177e4
LT		 673 printk("GDT-PCI: Use free address at 0x%x\n", i);
674 found = TRUE;
675 break;
676 }
677 }
678 if (!found) {
679 printk("GDT-PCI: No free address found!\n");
680 iounmap(ha->brd);
681 return 0;
682 }
683 }
684 memset_io(&dp6c_ptr->u, 0, sizeof(dp6c_ptr->u));
a52667f3 685 if (readl(&dp6c_ptr->u) != 0) {
1da177e4
LT		 686 printk("GDT-PCI: Initialization error (DPMEM write error)\n");
687 iounmap(ha->brd);
688 return 0;
689 }
690
691 /* disable board interrupts, deinit services */
692 outb(0x00,PTR2USHORT(&ha->plx->control1));
693 outb(0xff,PTR2USHORT(&ha->plx->edoor_reg));
694
a52667f3
JG		 695 writeb(0x00, &dp6c_ptr->u.ic.S_Status);
696 writeb(0x00, &dp6c_ptr->u.ic.Cmd_Index);
1da177e4 697
a52667f3
JG		 698 writel(pcistr->dpmem, &dp6c_ptr->u.ic.S_Info[0]);
699 writeb(0xff, &dp6c_ptr->u.ic.S_Cmd_Indx);
1da177e4
LT		 700
701 outb(1,PTR2USHORT(&ha->plx->ldoor_reg));
702
703 retries = INIT_RETRIES;
704 gdth_delay(20);
a52667f3 705 while (readb(&dp6c_ptr->u.ic.S_Status) != 0xff) {
1da177e4
LT		 706 if (--retries == 0) {
707 printk("GDT-PCI: Initialization error (DEINIT failed)\n");
708 iounmap(ha->brd);
709 return 0;
710 }
711 gdth_delay(1);
712 }
1fe6dbf4 713 prot_ver = (u8)readl(&dp6c_ptr->u.ic.S_Info[0]);
a52667f3 714 writeb(0, &dp6c_ptr->u.ic.Status);
1da177e4
LT		 715 if (prot_ver != PROTOCOL_VERSION) {
716 printk("GDT-PCI: Illegal protocol version\n");
717 iounmap(ha->brd);
718 return 0;
719 }
720
721 ha->type = GDT_PCINEW;
722 ha->ic_all_size = sizeof(dp6c_ptr->u);
723
724 /* special command to controller BIOS */
a52667f3
JG		 725 writel(0x00, &dp6c_ptr->u.ic.S_Info[0]);
726 writel(0x00, &dp6c_ptr->u.ic.S_Info[1]);
727 writel(0x00, &dp6c_ptr->u.ic.S_Info[2]);
728 writel(0x00, &dp6c_ptr->u.ic.S_Info[3]);
729 writeb(0xfe, &dp6c_ptr->u.ic.S_Cmd_Indx);
1da177e4
LT		 730
731 outb(1,PTR2USHORT(&ha->plx->ldoor_reg));
732
733 retries = INIT_RETRIES;
734 gdth_delay(20);
a52667f3 735 while (readb(&dp6c_ptr->u.ic.S_Status) != 0xfe) {
1da177e4
LT		 736 if (--retries == 0) {
737 printk("GDT-PCI: Initialization error\n");
738 iounmap(ha->brd);
739 return 0;
740 }
741 gdth_delay(1);
742 }
a52667f3 743 writeb(0, &dp6c_ptr->u.ic.S_Status);
1da177e4
LT		 744
745 ha->dma64_support = 0;
746
747 } else { /* MPR */
748 TRACE2(("init_pci_mpr() dpmem %lx irq %d\n",pcistr->dpmem,ha->irq));
749 ha->brd = ioremap(pcistr->dpmem, sizeof(gdt6m_dpram_str));
750 if (ha->brd == NULL) {
751 printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
752 return 0;
753 }
754
755 /* manipulate config. space to enable DPMEM, start RP controller */
4c9c8d78 756 pci_read_config_word(pdev, PCI_COMMAND, &command);
1da177e4 757 command |= 6;
4c9c8d78 758 pci_write_config_word(pdev, PCI_COMMAND, command);
8108de97
BH		 759 gdth_delay(1);
760
1da177e4
LT		 761 dp6m_ptr = ha->brd;
762
763 /* Ensure that it is safe to access the non HW portions of DPMEM.
764 * Aditional check needed for Xscale based RAID controllers */
a52667f3 765 while( ((int)readb(&dp6m_ptr->i960r.sema0_reg) ) & 3 )
1da177e4
LT		 766 gdth_delay(1);
767
768 /* check and reset interface area */
a52667f3
JG		 769 writel(DPMEM_MAGIC, &dp6m_ptr->u);
770 if (readl(&dp6m_ptr->u) != DPMEM_MAGIC) {
1da177e4
LT		 771 printk("GDT-PCI: Cannot access DPMEM at 0x%lx (shadowed?)\n",
772 pcistr->dpmem);
773 found = FALSE;
774 for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
775 iounmap(ha->brd);
1fe6dbf4 776 ha->brd = ioremap(i, sizeof(u16));
1da177e4
LT		 777 if (ha->brd == NULL) {
778 printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
779 return 0;
780 }
a52667f3 781 if (readw(ha->brd) != 0xffff) {
1da177e4
LT		 782 TRACE2(("init_pci_mpr() address 0x%x busy\n", i));
783 continue;
784 }
785 iounmap(ha->brd);
4c9c8d78 786 pci_write_config_dword(pdev, PCI_BASE_ADDRESS_0, i);
1da177e4
LT		 787 ha->brd = ioremap(i, sizeof(gdt6m_dpram_str));
788 if (ha->brd == NULL) {
789 printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
790 return 0;
791 }
792 dp6m_ptr = ha->brd;
a52667f3
JG		 793 writel(DPMEM_MAGIC, &dp6m_ptr->u);
794 if (readl(&dp6m_ptr->u) == DPMEM_MAGIC) {
1da177e4
LT		 795 printk("GDT-PCI: Use free address at 0x%x\n", i);
796 found = TRUE;
797 break;
798 }
799 }
800 if (!found) {
801 printk("GDT-PCI: No free address found!\n");
802 iounmap(ha->brd);
803 return 0;
804 }
805 }
806 memset_io(&dp6m_ptr->u, 0, sizeof(dp6m_ptr->u));
807
808 /* disable board interrupts, deinit services */
a52667f3 809 writeb(readb(&dp6m_ptr->i960r.edoor_en_reg) | 4,
1da177e4 810 &dp6m_ptr->i960r.edoor_en_reg);
a52667f3
JG		 811 writeb(0xff, &dp6m_ptr->i960r.edoor_reg);
812 writeb(0x00, &dp6m_ptr->u.ic.S_Status);
813 writeb(0x00, &dp6m_ptr->u.ic.Cmd_Index);
1da177e4 814
a52667f3
JG		 815 writel(pcistr->dpmem, &dp6m_ptr->u.ic.S_Info[0]);
816 writeb(0xff, &dp6m_ptr->u.ic.S_Cmd_Indx);
817 writeb(1, &dp6m_ptr->i960r.ldoor_reg);
1da177e4
LT		 818 retries = INIT_RETRIES;
819 gdth_delay(20);
a52667f3 820 while (readb(&dp6m_ptr->u.ic.S_Status) != 0xff) {
1da177e4
LT		 821 if (--retries == 0) {
822 printk("GDT-PCI: Initialization error (DEINIT failed)\n");
823 iounmap(ha->brd);
824 return 0;
825 }
826 gdth_delay(1);
827 }
1fe6dbf4 828 prot_ver = (u8)readl(&dp6m_ptr->u.ic.S_Info[0]);
a52667f3 829 writeb(0, &dp6m_ptr->u.ic.S_Status);
1da177e4
LT		 830 if (prot_ver != PROTOCOL_VERSION) {
831 printk("GDT-PCI: Illegal protocol version\n");
832 iounmap(ha->brd);
833 return 0;
834 }
835
836 ha->type = GDT_PCIMPR;
837 ha->ic_all_size = sizeof(dp6m_ptr->u);
838
839 /* special command to controller BIOS */
a52667f3
JG		 840 writel(0x00, &dp6m_ptr->u.ic.S_Info[0]);
841 writel(0x00, &dp6m_ptr->u.ic.S_Info[1]);
842 writel(0x00, &dp6m_ptr->u.ic.S_Info[2]);
843 writel(0x00, &dp6m_ptr->u.ic.S_Info[3]);
844 writeb(0xfe, &dp6m_ptr->u.ic.S_Cmd_Indx);
845 writeb(1, &dp6m_ptr->i960r.ldoor_reg);
1da177e4
LT		 846 retries = INIT_RETRIES;
847 gdth_delay(20);
a52667f3 848 while (readb(&dp6m_ptr->u.ic.S_Status) != 0xfe) {
1da177e4
LT		 849 if (--retries == 0) {
850 printk("GDT-PCI: Initialization error\n");
851 iounmap(ha->brd);
852 return 0;
853 }
854 gdth_delay(1);
855 }
a52667f3 856 writeb(0, &dp6m_ptr->u.ic.S_Status);
1da177e4
LT		 857
858 /* read FW version to detect 64-bit DMA support */
a52667f3
JG		 859 writeb(0xfd, &dp6m_ptr->u.ic.S_Cmd_Indx);
860 writeb(1, &dp6m_ptr->i960r.ldoor_reg);
1da177e4
LT		 861 retries = INIT_RETRIES;
862 gdth_delay(20);
a52667f3 863 while (readb(&dp6m_ptr->u.ic.S_Status) != 0xfd) {
1da177e4
LT		 864 if (--retries == 0) {
865 printk("GDT-PCI: Initialization error (DEINIT failed)\n");
866 iounmap(ha->brd);
867 return 0;
868 }
869 gdth_delay(1);
870 }
1fe6dbf4 871 prot_ver = (u8)(readl(&dp6m_ptr->u.ic.S_Info[0]) >> 16);
a52667f3 872 writeb(0, &dp6m_ptr->u.ic.S_Status);
1da177e4
LT		 873 if (prot_ver < 0x2b) /* FW < x.43: no 64-bit DMA support */
874 ha->dma64_support = 0;
875 else
876 ha->dma64_support = 1;
877 }
878
879 return 1;
880}
1da177e4
LT		 881
882/* controller protocol functions */
883
6f039790 884static void gdth_enable_int(gdth_ha_str *ha)
1da177e4 885{
1fe6dbf4 886 unsigned long flags;
1da177e4
LT		 887 gdt6_dpram_str __iomem *dp6_ptr;
888 gdt6m_dpram_str __iomem *dp6m_ptr;
889
45f1a41b 890 TRACE(("gdth_enable_int() hanum %d\n",ha->hanum));
1da177e4
LT		 891 spin_lock_irqsave(&ha->smp_lock, flags);
892
31481455 893 if (ha->type == GDT_PCI) {
1da177e4 894 dp6_ptr = ha->brd;
a52667f3
JG		 895 writeb(1, &dp6_ptr->io.irqdel);
896 writeb(0, &dp6_ptr->u.ic.Cmd_Index);
897 writeb(1, &dp6_ptr->io.irqen);
1da177e4
LT		 898 } else if (ha->type == GDT_PCINEW) {
899 outb(0xff, PTR2USHORT(&ha->plx->edoor_reg));
900 outb(0x03, PTR2USHORT(&ha->plx->control1));
901 } else if (ha->type == GDT_PCIMPR) {
902 dp6m_ptr = ha->brd;
a52667f3
JG		 903 writeb(0xff, &dp6m_ptr->i960r.edoor_reg);
904 writeb(readb(&dp6m_ptr->i960r.edoor_en_reg) & ~4,
1da177e4
LT		 905 &dp6m_ptr->i960r.edoor_en_reg);
906 }
907 spin_unlock_irqrestore(&ha->smp_lock, flags);
908}
909
10e1b4bc 910/* return IStatus if interrupt was from this card else 0 */
1fe6dbf4 911static u8 gdth_get_status(gdth_ha_str *ha)
1da177e4 912{
1fe6dbf4 913 u8 IStatus = 0;
10e1b4bc 914
230e886e 915 TRACE(("gdth_get_status() irq %d ctr_count %d\n", ha->irq, gdth_ctr_count));
1da177e4 916
31481455 917 if (ha->type == GDT_PCI)
10e1b4bc 918 IStatus =
a52667f3 919 readb(&((gdt6_dpram_str __iomem *)ha->brd)->u.ic.Cmd_Index);
1da177e4 920 else if (ha->type == GDT_PCINEW)
10e1b4bc 921 IStatus = inb(PTR2USHORT(&ha->plx->edoor_reg));
1da177e4 922 else if (ha->type == GDT_PCIMPR)
10e1b4bc 923 IStatus =
a52667f3 924 readb(&((gdt6m_dpram_str __iomem *)ha->brd)->i960r.edoor_reg);
10e1b4bc
BH		 925
926 return IStatus;
1da177e4 927}
10e1b4bc 928
45f1a41b 929static int gdth_test_busy(gdth_ha_str *ha)
1da177e4 930{
1da177e4
LT		 931 register int gdtsema0 = 0;
932
45f1a41b
BH		 933 TRACE(("gdth_test_busy() hanum %d\n", ha->hanum));
934
31481455 935 if (ha->type == GDT_PCI)
a52667f3 936 gdtsema0 = (int)readb(&((gdt6_dpram_str __iomem *)ha->brd)->u.ic.Sema0);
1da177e4
LT		 937 else if (ha->type == GDT_PCINEW)
938 gdtsema0 = (int)inb(PTR2USHORT(&ha->plx->sema0_reg));
939 else if (ha->type == GDT_PCIMPR)
940 gdtsema0 =
a52667f3 941 (int)readb(&((gdt6m_dpram_str __iomem *)ha->brd)->i960r.sema0_reg);
1da177e4
LT		 942
943 return (gdtsema0 & 1);
944}
945
946
45f1a41b 947static int gdth_get_cmd_index(gdth_ha_str *ha)
1da177e4 948{
1da177e4
LT		 949 int i;
950
45f1a41b 951 TRACE(("gdth_get_cmd_index() hanum %d\n", ha->hanum));
1da177e4 952
1da177e4
LT		 953 for (i=0; i<GDTH_MAXCMDS; ++i) {
954 if (ha->cmd_tab[i].cmnd == UNUSED_CMND) {
955 ha->cmd_tab[i].cmnd = ha->pccb->RequestBuffer;
956 ha->cmd_tab[i].service = ha->pccb->Service;
1fe6dbf4 957 ha->pccb->CommandIndex = (u32)i+2;
1da177e4
LT		 958 return (i+2);
959 }
960 }
961 return 0;
962}
963
964
45f1a41b 965static void gdth_set_sema0(gdth_ha_str *ha)
1da177e4 966{
45f1a41b 967 TRACE(("gdth_set_sema0() hanum %d\n", ha->hanum));
1da177e4 968
31481455 969 if (ha->type == GDT_PCI) {
a52667f3 970 writeb(1, &((gdt6_dpram_str __iomem *)ha->brd)->u.ic.Sema0);
1da177e4
LT		 971 } else if (ha->type == GDT_PCINEW) {
972 outb(1, PTR2USHORT(&ha->plx->sema0_reg));
973 } else if (ha->type == GDT_PCIMPR) {
a52667f3 974 writeb(1, &((gdt6m_dpram_str __iomem *)ha->brd)->i960r.sema0_reg);
1da177e4
LT		 975 }
976}
977
978
45f1a41b 979static void gdth_copy_command(gdth_ha_str *ha)
1da177e4 980{
1da177e4
LT		 981 register gdth_cmd_str *cmd_ptr;
982 register gdt6m_dpram_str __iomem *dp6m_ptr;
983 register gdt6c_dpram_str __iomem *dp6c_ptr;
984 gdt6_dpram_str __iomem *dp6_ptr;
1fe6dbf4 985 u16 cp_count,dp_offset,cmd_no;
1da177e4 986
45f1a41b 987 TRACE(("gdth_copy_command() hanum %d\n", ha->hanum));
1da177e4 988
1da177e4
LT		 989 cp_count = ha->cmd_len;
990 dp_offset= ha->cmd_offs_dpmem;
991 cmd_no = ha->cmd_cnt;
992 cmd_ptr = ha->pccb;
993
994 ++ha->cmd_cnt;
1da177e4
LT		 995
996 /* set cpcount dword aligned */
997 if (cp_count & 3)
998 cp_count += (4 - (cp_count & 3));
999
1000 ha->cmd_offs_dpmem += cp_count;
1001
1002 /* set offset and service, copy command to DPMEM */
31481455 1003 if (ha->type == GDT_PCI) {
1da177e4 1004 dp6_ptr = ha->brd;
a52667f3 1005 writew(dp_offset + DPMEM_COMMAND_OFFSET,
1da177e4 1006 &dp6_ptr->u.ic.comm_queue[cmd_no].offset);
1fe6dbf4 1007 writew((u16)cmd_ptr->Service,
1da177e4
LT		 1008 &dp6_ptr->u.ic.comm_queue[cmd_no].serv_id);
1009 memcpy_toio(&dp6_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
1010 } else if (ha->type == GDT_PCINEW) {
1011 dp6c_ptr = ha->brd;
a52667f3 1012 writew(dp_offset + DPMEM_COMMAND_OFFSET,
1da177e4 1013 &dp6c_ptr->u.ic.comm_queue[cmd_no].offset);
1fe6dbf4 1014 writew((u16)cmd_ptr->Service,
1da177e4
LT		 1015 &dp6c_ptr->u.ic.comm_queue[cmd_no].serv_id);
1016 memcpy_toio(&dp6c_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
1017 } else if (ha->type == GDT_PCIMPR) {
1018 dp6m_ptr = ha->brd;
a52667f3 1019 writew(dp_offset + DPMEM_COMMAND_OFFSET,
1da177e4 1020 &dp6m_ptr->u.ic.comm_queue[cmd_no].offset);
1fe6dbf4 1021 writew((u16)cmd_ptr->Service,
1da177e4
LT		 1022 &dp6m_ptr->u.ic.comm_queue[cmd_no].serv_id);
1023 memcpy_toio(&dp6m_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
1024 }
1025}
1026
1027
45f1a41b 1028static void gdth_release_event(gdth_ha_str *ha)
1da177e4 1029{
45f1a41b 1030 TRACE(("gdth_release_event() hanum %d\n", ha->hanum));
1da177e4
LT		 1031
1032#ifdef GDTH_STATISTICS
1033 {
1fe6dbf4 1034 u32 i,j;
1da177e4
LT		 1035 for (i=0,j=0; j<GDTH_MAXCMDS; ++j) {
1036 if (ha->cmd_tab[j].cmnd != UNUSED_CMND)
1037 ++i;
1038 }
1039 if (max_index < i) {
1040 max_index = i;
1fe6dbf4 1041 TRACE3(("GDT: max_index = %d\n",(u16)i));
1da177e4
LT		 1042 }
1043 }
1044#endif
1045
1046 if (ha->pccb->OpCode == GDT_INIT)
1047 ha->pccb->Service |= 0x80;
1048
31481455 1049 if (ha->type == GDT_PCI) {
a52667f3 1050 writeb(0, &((gdt6_dpram_str __iomem *)ha->brd)->io.event);
1da177e4
LT		 1051 } else if (ha->type == GDT_PCINEW) {
1052 outb(1, PTR2USHORT(&ha->plx->ldoor_reg));
1053 } else if (ha->type == GDT_PCIMPR) {
a52667f3 1054 writeb(1, &((gdt6m_dpram_str __iomem *)ha->brd)->i960r.ldoor_reg);
1da177e4
LT		 1055 }
1056}
1057
1fe6dbf4 1058static int gdth_wait(gdth_ha_str *ha, int index, u32 time)
1da177e4 1059{
1da177e4 1060 int answer_found = FALSE;
10e1b4bc 1061 int wait_index = 0;
1da177e4 1062
45f1a41b 1063 TRACE(("gdth_wait() hanum %d index %d time %d\n", ha->hanum, index, time));
1da177e4 1064
1da177e4
LT		 1065 if (index == 0)
1066 return 1; /* no wait required */
1067
1da177e4 1068 do {
230e886e 1069 __gdth_interrupt(ha, true, &wait_index);
10e1b4bc 1070 if (wait_index == index) {
1da177e4
LT		 1071 answer_found = TRUE;
1072 break;
1073 }
1074 gdth_delay(1);
1075 } while (--time);
45f1a41b
BH		 1076
1077 while (gdth_test_busy(ha))
1da177e4
LT		 1078 gdth_delay(0);
1079
1080 return (answer_found);
1081}
1082
1083
1fe6dbf4
DJ		 1084static int gdth_internal_cmd(gdth_ha_str *ha, u8 service, u16 opcode,
1085 u32 p1, u64 p2, u64 p3)
1da177e4 1086{
1da177e4
LT		 1087 register gdth_cmd_str *cmd_ptr;
1088 int retries,index;
1089
1090 TRACE2(("gdth_internal_cmd() service %d opcode %d\n",service,opcode));
1091
1da177e4
LT		 1092 cmd_ptr = ha->pccb;
1093 memset((char*)cmd_ptr,0,sizeof(gdth_cmd_str));
1094
1095 /* make command */
1096 for (retries = INIT_RETRIES;;) {
1097 cmd_ptr->Service = service;
1098 cmd_ptr->RequestBuffer = INTERNAL_CMND;
45f1a41b 1099 if (!(index=gdth_get_cmd_index(ha))) {
1da177e4
LT		 1100 TRACE(("GDT: No free command index found\n"));
1101 return 0;
1102 }
45f1a41b 1103 gdth_set_sema0(ha);
1da177e4
LT		 1104 cmd_ptr->OpCode = opcode;
1105 cmd_ptr->BoardNode = LOCALBOARD;
1106 if (service == CACHESERVICE) {
1107 if (opcode == GDT_IOCTL) {
1108 cmd_ptr->u.ioctl.subfunc = p1;
1fe6dbf4
DJ		 1109 cmd_ptr->u.ioctl.channel = (u32)p2;
1110 cmd_ptr->u.ioctl.param_size = (u16)p3;
1da177e4
LT		 1111 cmd_ptr->u.ioctl.p_param = ha->scratch_phys;
1112 } else {
1113 if (ha->cache_feat & GDT_64BIT) {
1fe6dbf4 1114 cmd_ptr->u.cache64.DeviceNo = (u16)p1;
1da177e4
LT		 1115 cmd_ptr->u.cache64.BlockNo = p2;
1116 } else {
1fe6dbf4
DJ		 1117 cmd_ptr->u.cache.DeviceNo = (u16)p1;
1118 cmd_ptr->u.cache.BlockNo = (u32)p2;
1da177e4
LT		 1119 }
1120 }
1121 } else if (service == SCSIRAWSERVICE) {
1122 if (ha->raw_feat & GDT_64BIT) {
1123 cmd_ptr->u.raw64.direction = p1;
1fe6dbf4
DJ		 1124 cmd_ptr->u.raw64.bus = (u8)p2;
1125 cmd_ptr->u.raw64.target = (u8)p3;
1126 cmd_ptr->u.raw64.lun = (u8)(p3 >> 8);
1da177e4
LT		 1127 } else {
1128 cmd_ptr->u.raw.direction = p1;
1fe6dbf4
DJ		 1129 cmd_ptr->u.raw.bus = (u8)p2;
1130 cmd_ptr->u.raw.target = (u8)p3;
1131 cmd_ptr->u.raw.lun = (u8)(p3 >> 8);
1da177e4
LT		 1132 }
1133 } else if (service == SCREENSERVICE) {
1134 if (opcode == GDT_REALTIME) {
1fe6dbf4
DJ		 1135 *(u32 *)&cmd_ptr->u.screen.su.data[0] = p1;
1136 *(u32 *)&cmd_ptr->u.screen.su.data[4] = (u32)p2;
1137 *(u32 *)&cmd_ptr->u.screen.su.data[8] = (u32)p3;
1da177e4
LT		 1138 }
1139 }
1140 ha->cmd_len = sizeof(gdth_cmd_str);
1141 ha->cmd_offs_dpmem = 0;
1142 ha->cmd_cnt = 0;
45f1a41b
BH		 1143 gdth_copy_command(ha);
1144 gdth_release_event(ha);
1da177e4 1145 gdth_delay(20);
45f1a41b 1146 if (!gdth_wait(ha, index, INIT_TIMEOUT)) {
1da177e4
LT		 1147 printk("GDT: Initialization error (timeout service %d)\n",service);
1148 return 0;
1149 }
1150 if (ha->status != S_BSY || --retries == 0)
1151 break;
1152 gdth_delay(1);
1153 }
1154
1155 return (ha->status != S_OK ? 0:1);
1156}
1157
1158
1159/* search for devices */
1160
6f039790 1161static int gdth_search_drives(gdth_ha_str *ha)
1da177e4 1162{
1fe6dbf4 1163 u16 cdev_cnt, i;
1da177e4 1164 int ok;
1fe6dbf4 1165 u32 bus_no, drv_cnt, drv_no, j;
1da177e4
LT		 1166 gdth_getch_str *chn;
1167 gdth_drlist_str *drl;
1168 gdth_iochan_str *ioc;
1169 gdth_raw_iochan_str *iocr;
1170 gdth_arcdl_str *alst;
1171 gdth_alist_str *alst2;
1172 gdth_oem_str_ioctl *oemstr;
1da177e4 1173
45f1a41b 1174 TRACE(("gdth_search_drives() hanum %d\n", ha->hanum));
1da177e4
LT		 1175 ok = 0;
1176
1177 /* initialize controller services, at first: screen service */
1178 ha->screen_feat = 0;
1179 if (!force_dma32) {
45f1a41b 1180 ok = gdth_internal_cmd(ha, SCREENSERVICE, GDT_X_INIT_SCR, 0, 0, 0);
1da177e4
LT		 1181 if (ok)
1182 ha->screen_feat = GDT_64BIT;
1183 }
1fe6dbf4 1184 if (force_dma32 || (!ok && ha->status == (u16)S_NOFUNC))
45f1a41b 1185 ok = gdth_internal_cmd(ha, SCREENSERVICE, GDT_INIT, 0, 0, 0);
1da177e4
LT		 1186 if (!ok) {
1187 printk("GDT-HA %d: Initialization error screen service (code %d)\n",
45f1a41b 1188 ha->hanum, ha->status);
1da177e4
LT		 1189 return 0;
1190 }
1191 TRACE2(("gdth_search_drives(): SCREENSERVICE initialized\n"));
1192
1da177e4 1193 /* unfreeze all IOs */
45f1a41b 1194 gdth_internal_cmd(ha, CACHESERVICE, GDT_UNFREEZE_IO, 0, 0, 0);
1da177e4
LT		 1195
1196 /* initialize cache service */
1197 ha->cache_feat = 0;
1198 if (!force_dma32) {
45f1a41b
BH		 1199 ok = gdth_internal_cmd(ha, CACHESERVICE, GDT_X_INIT_HOST, LINUX_OS,
1200 0, 0);
1da177e4
LT		 1201 if (ok)
1202 ha->cache_feat = GDT_64BIT;
1203 }
1fe6dbf4 1204 if (force_dma32 || (!ok && ha->status == (u16)S_NOFUNC))
45f1a41b 1205 ok = gdth_internal_cmd(ha, CACHESERVICE, GDT_INIT, LINUX_OS, 0, 0);
1da177e4
LT		 1206 if (!ok) {
1207 printk("GDT-HA %d: Initialization error cache service (code %d)\n",
45f1a41b 1208 ha->hanum, ha->status);
1da177e4
LT		 1209 return 0;
1210 }
1211 TRACE2(("gdth_search_drives(): CACHESERVICE initialized\n"));
1fe6dbf4 1212 cdev_cnt = (u16)ha->info;
1da177e4
LT		 1213 ha->fw_vers = ha->service;
1214
1da177e4
LT		 1215 /* detect number of buses - try new IOCTL */
1216 iocr = (gdth_raw_iochan_str *)ha->pscratch;
1217 iocr->hdr.version = 0xffffffff;
1218 iocr->hdr.list_entries = MAXBUS;
1219 iocr->hdr.first_chan = 0;
1220 iocr->hdr.last_chan = MAXBUS-1;
1221 iocr->hdr.list_offset = GDTOFFSOF(gdth_raw_iochan_str, list[0]);
45f1a41b 1222 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL, IOCHAN_RAW_DESC,
1da177e4
LT		 1223 INVALID_CHANNEL,sizeof(gdth_raw_iochan_str))) {
1224 TRACE2(("IOCHAN_RAW_DESC supported!\n"));
1225 ha->bus_cnt = iocr->hdr.chan_count;
1226 for (bus_no = 0; bus_no < ha->bus_cnt; ++bus_no) {
1227 if (iocr->list[bus_no].proc_id < MAXID)
1228 ha->bus_id[bus_no] = iocr->list[bus_no].proc_id;
1229 else
1230 ha->bus_id[bus_no] = 0xff;
1231 }
1232 } else {
1233 /* old method */
1234 chn = (gdth_getch_str *)ha->pscratch;
1235 for (bus_no = 0; bus_no < MAXBUS; ++bus_no) {
1236 chn->channel_no = bus_no;
45f1a41b 1237 if (!gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL,
1da177e4
LT		 1238 SCSI_CHAN_CNT | L_CTRL_PATTERN,
1239 IO_CHANNEL | INVALID_CHANNEL,
1240 sizeof(gdth_getch_str))) {
1241 if (bus_no == 0) {
1242 printk("GDT-HA %d: Error detecting channel count (0x%x)\n",
45f1a41b 1243 ha->hanum, ha->status);
1da177e4
LT		 1244 return 0;
1245 }
1246 break;
1247 }
1248 if (chn->siop_id < MAXID)
1249 ha->bus_id[bus_no] = chn->siop_id;
1250 else
1251 ha->bus_id[bus_no] = 0xff;
1252 }
1fe6dbf4 1253 ha->bus_cnt = (u8)bus_no;
1da177e4
LT		 1254 }
1255 TRACE2(("gdth_search_drives() %d channels\n",ha->bus_cnt));
1256
1257 /* read cache configuration */
45f1a41b 1258 if (!gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL, CACHE_INFO,
1da177e4
LT		 1259 INVALID_CHANNEL,sizeof(gdth_cinfo_str))) {
1260 printk("GDT-HA %d: Initialization error cache service (code %d)\n",
45f1a41b 1261 ha->hanum, ha->status);
1da177e4
LT		 1262 return 0;
1263 }
1264 ha->cpar = ((gdth_cinfo_str *)ha->pscratch)->cpar;
1265 TRACE2(("gdth_search_drives() cinfo: vs %x sta %d str %d dw %d b %d\n",
1266 ha->cpar.version,ha->cpar.state,ha->cpar.strategy,
1267 ha->cpar.write_back,ha->cpar.block_size));
1268
1269 /* read board info and features */
1270 ha->more_proc = FALSE;
45f1a41b 1271 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL, BOARD_INFO,
1da177e4
LT		 1272 INVALID_CHANNEL,sizeof(gdth_binfo_str))) {
1273 memcpy(&ha->binfo, (gdth_binfo_str *)ha->pscratch,
1274 sizeof(gdth_binfo_str));
45f1a41b 1275 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL, BOARD_FEATURES,
1da177e4
LT		 1276 INVALID_CHANNEL,sizeof(gdth_bfeat_str))) {
1277 TRACE2(("BOARD_INFO/BOARD_FEATURES supported\n"));
1278 ha->bfeat = *(gdth_bfeat_str *)ha->pscratch;
1279 ha->more_proc = TRUE;
1280 }
1281 } else {
1282 TRACE2(("BOARD_INFO requires firmware >= 1.10/2.08\n"));
45f1a41b 1283 strcpy(ha->binfo.type_string, gdth_ctr_name(ha));
1da177e4
LT		 1284 }
1285 TRACE2(("Controller name: %s\n",ha->binfo.type_string));
1286
1287 /* read more informations */
1288 if (ha->more_proc) {
1289 /* physical drives, channel addresses */
1290 ioc = (gdth_iochan_str *)ha->pscratch;
1291 ioc->hdr.version = 0xffffffff;
1292 ioc->hdr.list_entries = MAXBUS;
1293 ioc->hdr.first_chan = 0;
1294 ioc->hdr.last_chan = MAXBUS-1;
1295 ioc->hdr.list_offset = GDTOFFSOF(gdth_iochan_str, list[0]);
45f1a41b 1296 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL, IOCHAN_DESC,
1da177e4
LT		 1297 INVALID_CHANNEL,sizeof(gdth_iochan_str))) {
1298 for (bus_no = 0; bus_no < ha->bus_cnt; ++bus_no) {
1299 ha->raw[bus_no].address = ioc->list[bus_no].address;
1300 ha->raw[bus_no].local_no = ioc->list[bus_no].local_no;
1301 }
1302 } else {
1303 for (bus_no = 0; bus_no < ha->bus_cnt; ++bus_no) {
1304 ha->raw[bus_no].address = IO_CHANNEL;
1305 ha->raw[bus_no].local_no = bus_no;
1306 }
1307 }
1308 for (bus_no = 0; bus_no < ha->bus_cnt; ++bus_no) {
1309 chn = (gdth_getch_str *)ha->pscratch;
1310 chn->channel_no = ha->raw[bus_no].local_no;
45f1a41b 1311 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL,
1da177e4
LT		 1312 SCSI_CHAN_CNT | L_CTRL_PATTERN,
1313 ha->raw[bus_no].address | INVALID_CHANNEL,
1314 sizeof(gdth_getch_str))) {
1315 ha->raw[bus_no].pdev_cnt = chn->drive_cnt;
1316 TRACE2(("Channel %d: %d phys. drives\n",
1317 bus_no,chn->drive_cnt));
1318 }
1319 if (ha->raw[bus_no].pdev_cnt > 0) {
1320 drl = (gdth_drlist_str *)ha->pscratch;
1321 drl->sc_no = ha->raw[bus_no].local_no;
1322 drl->sc_cnt = ha->raw[bus_no].pdev_cnt;
45f1a41b 1323 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL,
1da177e4
LT		 1324 SCSI_DR_LIST | L_CTRL_PATTERN,
1325 ha->raw[bus_no].address | INVALID_CHANNEL,
1326 sizeof(gdth_drlist_str))) {
1327 for (j = 0; j < ha->raw[bus_no].pdev_cnt; ++j)
1328 ha->raw[bus_no].id_list[j] = drl->sc_list[j];
1329 } else {
1330 ha->raw[bus_no].pdev_cnt = 0;
1331 }
1332 }
1333 }
1334
1335 /* logical drives */
45f1a41b 1336 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL, CACHE_DRV_CNT,
1fe6dbf4
DJ		 1337 INVALID_CHANNEL,sizeof(u32))) {
1338 drv_cnt = *(u32 *)ha->pscratch;
45f1a41b 1339 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL, CACHE_DRV_LIST,
1fe6dbf4 1340 INVALID_CHANNEL,drv_cnt * sizeof(u32))) {
1da177e4 1341 for (j = 0; j < drv_cnt; ++j) {
1fe6dbf4 1342 drv_no = ((u32 *)ha->pscratch)[j];
1da177e4
LT		 1343 if (drv_no < MAX_LDRIVES) {
1344 ha->hdr[drv_no].is_logdrv = TRUE;
1345 TRACE2(("Drive %d is log. drive\n",drv_no));
1346 }
1347 }
1348 }
1349 alst = (gdth_arcdl_str *)ha->pscratch;
1350 alst->entries_avail = MAX_LDRIVES;
1351 alst->first_entry = 0;
1352 alst->list_offset = GDTOFFSOF(gdth_arcdl_str, list[0]);
45f1a41b 1353 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL,
1da177e4
LT		 1354 ARRAY_DRV_LIST2 | LA_CTRL_PATTERN,
1355 INVALID_CHANNEL, sizeof(gdth_arcdl_str) +
1356 (alst->entries_avail-1) * sizeof(gdth_alist_str))) {
1357 for (j = 0; j < alst->entries_init; ++j) {
1358 ha->hdr[j].is_arraydrv = alst->list[j].is_arrayd;
1359 ha->hdr[j].is_master = alst->list[j].is_master;
1360 ha->hdr[j].is_parity = alst->list[j].is_parity;
1361 ha->hdr[j].is_hotfix = alst->list[j].is_hotfix;
1362 ha->hdr[j].master_no = alst->list[j].cd_handle;
1363 }
45f1a41b 1364 } else if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL,
1da177e4
LT		 1365 ARRAY_DRV_LIST | LA_CTRL_PATTERN,
1366 0, 35 * sizeof(gdth_alist_str))) {
1367 for (j = 0; j < 35; ++j) {
1368 alst2 = &((gdth_alist_str *)ha->pscratch)[j];
1369 ha->hdr[j].is_arraydrv = alst2->is_arrayd;
1370 ha->hdr[j].is_master = alst2->is_master;
1371 ha->hdr[j].is_parity = alst2->is_parity;
1372 ha->hdr[j].is_hotfix = alst2->is_hotfix;
1373 ha->hdr[j].master_no = alst2->cd_handle;
1374 }
1375 }
1376 }
1377 }
1378
1379 /* initialize raw service */
1380 ha->raw_feat = 0;
1381 if (!force_dma32) {
45f1a41b 1382 ok = gdth_internal_cmd(ha, SCSIRAWSERVICE, GDT_X_INIT_RAW, 0, 0, 0);
1da177e4
LT		 1383 if (ok)
1384 ha->raw_feat = GDT_64BIT;
1385 }
1fe6dbf4 1386 if (force_dma32 || (!ok && ha->status == (u16)S_NOFUNC))
45f1a41b 1387 ok = gdth_internal_cmd(ha, SCSIRAWSERVICE, GDT_INIT, 0, 0, 0);
1da177e4
LT		 1388 if (!ok) {
1389 printk("GDT-HA %d: Initialization error raw service (code %d)\n",
45f1a41b 1390 ha->hanum, ha->status);
1da177e4
LT		 1391 return 0;
1392 }
1393 TRACE2(("gdth_search_drives(): RAWSERVICE initialized\n"));
1394
1395 /* set/get features raw service (scatter/gather) */
45f1a41b
BH		 1396 if (gdth_internal_cmd(ha, SCSIRAWSERVICE, GDT_SET_FEAT, SCATTER_GATHER,
1397 0, 0)) {
1da177e4 1398 TRACE2(("gdth_search_drives(): set features RAWSERVICE OK\n"));
45f1a41b 1399 if (gdth_internal_cmd(ha, SCSIRAWSERVICE, GDT_GET_FEAT, 0, 0, 0)) {
1da177e4
LT		 1400 TRACE2(("gdth_search_dr(): get feat RAWSERVICE %d\n",
1401 ha->info));
1fe6dbf4 1402 ha->raw_feat |= (u16)ha->info;
1da177e4
LT		 1403 }
1404 }
1405
1406 /* set/get features cache service (equal to raw service) */
45f1a41b 1407 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_SET_FEAT, 0,
1da177e4
LT		 1408 SCATTER_GATHER,0)) {
1409 TRACE2(("gdth_search_drives(): set features CACHESERVICE OK\n"));
45f1a41b 1410 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_GET_FEAT, 0, 0, 0)) {
1da177e4
LT		 1411 TRACE2(("gdth_search_dr(): get feat CACHESERV. %d\n",
1412 ha->info));
1fe6dbf4 1413 ha->cache_feat |= (u16)ha->info;
1da177e4
LT		 1414 }
1415 }
1416
1417 /* reserve drives for raw service */
1418 if (reserve_mode != 0) {
45f1a41b 1419 gdth_internal_cmd(ha, SCSIRAWSERVICE, GDT_RESERVE_ALL,
1da177e4
LT		 1420 reserve_mode == 1 ? 1 : 3, 0, 0);
1421 TRACE2(("gdth_search_drives(): RESERVE_ALL code %d\n",
1422 ha->status));
1423 }
1424 for (i = 0; i < MAX_RES_ARGS; i += 4) {
45f1a41b 1425 if (reserve_list[i] == ha->hanum && reserve_list[i+1] < ha->bus_cnt &&
1da177e4
LT		 1426 reserve_list[i+2] < ha->tid_cnt && reserve_list[i+3] < MAXLUN) {
1427 TRACE2(("gdth_search_drives(): reserve ha %d bus %d id %d lun %d\n",
1428 reserve_list[i], reserve_list[i+1],
1429 reserve_list[i+2], reserve_list[i+3]));
45f1a41b 1430 if (!gdth_internal_cmd(ha, SCSIRAWSERVICE, GDT_RESERVE, 0,
1da177e4
LT		 1431 reserve_list[i+1], reserve_list[i+2] |
1432 (reserve_list[i+3] << 8))) {
1433 printk("GDT-HA %d: Error raw service (RESERVE, code %d)\n",
45f1a41b 1434 ha->hanum, ha->status);
1da177e4
LT		 1435 }
1436 }
1437 }
1438
1439 /* Determine OEM string using IOCTL */
1440 oemstr = (gdth_oem_str_ioctl *)ha->pscratch;
1441 oemstr->params.ctl_version = 0x01;
1442 oemstr->params.buffer_size = sizeof(oemstr->text);
45f1a41b 1443 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL,
1da177e4
LT		 1444 CACHE_READ_OEM_STRING_RECORD,INVALID_CHANNEL,
1445 sizeof(gdth_oem_str_ioctl))) {
1446 TRACE2(("gdth_search_drives(): CACHE_READ_OEM_STRING_RECORD OK\n"));
1447 printk("GDT-HA %d: Vendor: %s Name: %s\n",
45f1a41b 1448 ha->hanum, oemstr->text.oem_company_name, ha->binfo.type_string);
1da177e4 1449 /* Save the Host Drive inquiry data */
1da177e4
LT		 1450 strlcpy(ha->oem_name,oemstr->text.scsi_host_drive_inquiry_vendor_id,
1451 sizeof(ha->oem_name));
1da177e4
LT		 1452 } else {
1453 /* Old method, based on PCI ID */
1454 TRACE2(("gdth_search_drives(): CACHE_READ_OEM_STRING_RECORD failed\n"));
1455 printk("GDT-HA %d: Name: %s\n",
45f1a41b 1456 ha->hanum, ha->binfo.type_string);
1da177e4
LT		 1457 if (ha->oem_id == OEM_ID_INTEL)
1458 strlcpy(ha->oem_name,"Intel ", sizeof(ha->oem_name));
1459 else
1460 strlcpy(ha->oem_name,"ICP ", sizeof(ha->oem_name));
1da177e4
LT		 1461 }
1462
1463 /* scanning for host drives */
1464 for (i = 0; i < cdev_cnt; ++i)
45f1a41b 1465 gdth_analyse_hdrive(ha, i);
1da177e4
LT		 1466
1467 TRACE(("gdth_search_drives() OK\n"));
1468 return 1;
1469}
1470
1fe6dbf4 1471static int gdth_analyse_hdrive(gdth_ha_str *ha, u16 hdrive)
1da177e4 1472{
1fe6dbf4 1473 u32 drv_cyls;
1da177e4
LT		 1474 int drv_hds, drv_secs;
1475
45f1a41b 1476 TRACE(("gdth_analyse_hdrive() hanum %d drive %d\n", ha->hanum, hdrive));
1da177e4
LT		 1477 if (hdrive >= MAX_HDRIVES)
1478 return 0;
1da177e4 1479
45f1a41b 1480 if (!gdth_internal_cmd(ha, CACHESERVICE, GDT_INFO, hdrive, 0, 0))
1da177e4
LT		 1481 return 0;
1482 ha->hdr[hdrive].present = TRUE;
1483 ha->hdr[hdrive].size = ha->info;
1484
1485 /* evaluate mapping (sectors per head, heads per cylinder) */
1486 ha->hdr[hdrive].size &= ~SECS32;
1487 if (ha->info2 == 0) {
1488 gdth_eval_mapping(ha->hdr[hdrive].size,&drv_cyls,&drv_hds,&drv_secs);
1489 } else {
1490 drv_hds = ha->info2 & 0xff;
1491 drv_secs = (ha->info2 >> 8) & 0xff;
1fe6dbf4 1492 drv_cyls = (u32)ha->hdr[hdrive].size / drv_hds / drv_secs;
1da177e4 1493 }
1fe6dbf4
DJ		 1494 ha->hdr[hdrive].heads = (u8)drv_hds;
1495 ha->hdr[hdrive].secs = (u8)drv_secs;
1da177e4
LT		 1496 /* round size */
1497 ha->hdr[hdrive].size = drv_cyls * drv_hds * drv_secs;
1498
1499 if (ha->cache_feat & GDT_64BIT) {
45f1a41b 1500 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_X_INFO, hdrive, 0, 0)
1da177e4 1501 && ha->info2 != 0) {
1fe6dbf4 1502 ha->hdr[hdrive].size = ((u64)ha->info2 << 32) | ha->info;
1da177e4
LT		 1503 }
1504 }
1505 TRACE2(("gdth_search_dr() cdr. %d size %d hds %d scs %d\n",
1506 hdrive,ha->hdr[hdrive].size,drv_hds,drv_secs));
1507
1508 /* get informations about device */
45f1a41b 1509 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_DEVTYPE, hdrive, 0, 0)) {
1da177e4
LT		 1510 TRACE2(("gdth_search_dr() cache drive %d devtype %d\n",
1511 hdrive,ha->info));
1fe6dbf4 1512 ha->hdr[hdrive].devtype = (u16)ha->info;
1da177e4
LT		 1513 }
1514
1515 /* cluster info */
45f1a41b 1516 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_CLUST_INFO, hdrive, 0, 0)) {
1da177e4
LT		 1517 TRACE2(("gdth_search_dr() cache drive %d cluster info %d\n",
1518 hdrive,ha->info));
1519 if (!shared_access)
1fe6dbf4 1520 ha->hdr[hdrive].cluster_type = (u8)ha->info;
1da177e4
LT		 1521 }
1522
1523 /* R/W attributes */
45f1a41b 1524 if (gdth_internal_cmd(ha, CACHESERVICE, GDT_RW_ATTRIBS, hdrive, 0, 0)) {
1da177e4
LT		 1525 TRACE2(("gdth_search_dr() cache drive %d r/w attrib. %d\n",
1526 hdrive,ha->info));
1fe6dbf4 1527 ha->hdr[hdrive].rw_attribs = (u8)ha->info;
1da177e4
LT		 1528 }
1529
1530 return 1;
1531}
1532
1533
1534/* command queueing/sending functions */
1535
91ebc1fa 1536static void gdth_putq(gdth_ha_str *ha, struct scsi_cmnd *scp, u8 priority)
1da177e4 1537{
3058d5de 1538 struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
91ebc1fa
JT		 1539 register struct scsi_cmnd *pscp;
1540 register struct scsi_cmnd *nscp;
1fe6dbf4 1541 unsigned long flags;
1da177e4
LT		 1542
1543 TRACE(("gdth_putq() priority %d\n",priority));
1da177e4
LT		 1544 spin_lock_irqsave(&ha->smp_lock, flags);
1545
242f9dcb 1546 if (!cmndinfo->internal_command)
f842b64e 1547 cmndinfo->priority = priority;
1da177e4
LT		 1548
1549 if (ha->req_first==NULL) {
1550 ha->req_first = scp; /* queue was empty */
1551 scp->SCp.ptr = NULL;
1552 } else { /* queue not empty */
1553 pscp = ha->req_first;
91ebc1fa 1554 nscp = (struct scsi_cmnd *)pscp->SCp.ptr;
1da177e4 1555 /* priority: 0-highest,..,0xff-lowest */
f842b64e 1556 while (nscp && gdth_cmnd_priv(nscp)->priority <= priority) {
1da177e4 1557 pscp = nscp;
91ebc1fa 1558 nscp = (struct scsi_cmnd *)pscp->SCp.ptr;
1da177e4
LT		 1559 }
1560 pscp->SCp.ptr = (char *)scp;
1561 scp->SCp.ptr = (char *)nscp;
1562 }
1563 spin_unlock_irqrestore(&ha->smp_lock, flags);
1564
1565#ifdef GDTH_STATISTICS
1566 flags = 0;
91ebc1fa 1567 for (nscp=ha->req_first; nscp; nscp=(struct scsi_cmnd*)nscp->SCp.ptr)
1da177e4
LT		 1568 ++flags;
1569 if (max_rq < flags) {
1570 max_rq = flags;
1fe6dbf4 1571 TRACE3(("GDT: max_rq = %d\n",(u16)max_rq));
1da177e4
LT		 1572 }
1573#endif
1574}
1575
45f1a41b 1576static void gdth_next(gdth_ha_str *ha)
1da177e4 1577{
91ebc1fa
JT		 1578 register struct scsi_cmnd *pscp;
1579 register struct scsi_cmnd *nscp;
1fe6dbf4
DJ		 1580 u8 b, t, l, firsttime;
1581 u8 this_cmd, next_cmd;
1582 unsigned long flags = 0;
1da177e4
LT		 1583 int cmd_index;
1584
45f1a41b 1585 TRACE(("gdth_next() hanum %d\n", ha->hanum));
1da177e4
LT		 1586 if (!gdth_polling)
1587 spin_lock_irqsave(&ha->smp_lock, flags);
1588
1589 ha->cmd_cnt = ha->cmd_offs_dpmem = 0;
1590 this_cmd = firsttime = TRUE;
1591 next_cmd = gdth_polling ? FALSE:TRUE;
1592 cmd_index = 0;
1593
91ebc1fa 1594 for (nscp = pscp = ha->req_first; nscp; nscp = (struct scsi_cmnd *)nscp->SCp.ptr) {
f842b64e 1595 struct gdth_cmndinfo *nscp_cmndinfo = gdth_cmnd_priv(nscp);
91ebc1fa
JT		 1596 if (nscp != pscp && nscp != (struct scsi_cmnd *)pscp->SCp.ptr)
1597 pscp = (struct scsi_cmnd *)pscp->SCp.ptr;
f842b64e 1598 if (!nscp_cmndinfo->internal_command) {
52759e6a 1599 b = nscp->device->channel;
cbd5f69b
LA		 1600 t = nscp->device->id;
1601 l = nscp->device->lun;
f842b64e 1602 if (nscp_cmndinfo->priority >= DEFAULT_PRI) {
cbd5f69b
LA		 1603 if ((b != ha->virt_bus && ha->raw[BUS_L2P(ha,b)].lock) ||
1604 (b == ha->virt_bus && t < MAX_HDRIVES && ha->hdr[t].lock))
1605 continue;
1606 }
1607 } else
1608 b = t = l = 0;
1da177e4
LT		 1609
1610 if (firsttime) {
45f1a41b
BH		 1611 if (gdth_test_busy(ha)) { /* controller busy ? */
1612 TRACE(("gdth_next() controller %d busy !\n", ha->hanum));
1da177e4
LT		 1613 if (!gdth_polling) {
1614 spin_unlock_irqrestore(&ha->smp_lock, flags);
1615 return;
1616 }
45f1a41b 1617 while (gdth_test_busy(ha))
1da177e4
LT		 1618 gdth_delay(1);
1619 }
1620 firsttime = FALSE;
1621 }
1622
f842b64e
BH		 1623 if (!nscp_cmndinfo->internal_command) {
1624 if (nscp_cmndinfo->phase == -1) {
1625 nscp_cmndinfo->phase = CACHESERVICE; /* default: cache svc. */
1da177e4
LT		 1626 if (nscp->cmnd[0] == TEST_UNIT_READY) {
1627 TRACE2(("TEST_UNIT_READY Bus %d Id %d LUN %d\n",
1628 b, t, l));
1629 /* TEST_UNIT_READY -> set scan mode */
1630 if ((ha->scan_mode & 0x0f) == 0) {
1631 if (b == 0 && t == 0 && l == 0) {
1632 ha->scan_mode |= 1;
1633 TRACE2(("Scan mode: 0x%x\n", ha->scan_mode));
1634 }
1635 } else if ((ha->scan_mode & 0x0f) == 1) {
1636 if (b == 0 && ((t == 0 && l == 1) ||
1637 (t == 1 && l == 0))) {
f842b64e
BH		 1638 nscp_cmndinfo->OpCode = GDT_SCAN_START;
1639 nscp_cmndinfo->phase = ((ha->scan_mode & 0x10 ? 1:0) << 8)
1da177e4
LT		 1640 | SCSIRAWSERVICE;
1641 ha->scan_mode = 0x12;
1642 TRACE2(("Scan mode: 0x%x (SCAN_START)\n",
1643 ha->scan_mode));
1644 } else {
1645 ha->scan_mode &= 0x10;
1646 TRACE2(("Scan mode: 0x%x\n", ha->scan_mode));
1647 }
1648 } else if (ha->scan_mode == 0x12) {
1649 if (b == ha->bus_cnt && t == ha->tid_cnt-1) {
f842b64e
BH		 1650 nscp_cmndinfo->phase = SCSIRAWSERVICE;
1651 nscp_cmndinfo->OpCode = GDT_SCAN_END;
1da177e4
LT		 1652 ha->scan_mode &= 0x10;
1653 TRACE2(("Scan mode: 0x%x (SCAN_END)\n",
1654 ha->scan_mode));
1655 }
1656 }
1657 }
1658 if (b == ha->virt_bus && nscp->cmnd[0] != INQUIRY &&
1659 nscp->cmnd[0] != READ_CAPACITY && nscp->cmnd[0] != MODE_SENSE &&
1660 (ha->hdr[t].cluster_type & CLUSTER_DRIVE)) {
1661 /* always GDT_CLUST_INFO! */
f842b64e 1662 nscp_cmndinfo->OpCode = GDT_CLUST_INFO;
1da177e4
LT		 1663 }
1664 }
1665 }
1666
f842b64e
BH		 1667 if (nscp_cmndinfo->OpCode != -1) {
1668 if ((nscp_cmndinfo->phase & 0xff) == CACHESERVICE) {
45f1a41b 1669 if (!(cmd_index=gdth_fill_cache_cmd(ha, nscp, t)))
1da177e4
LT		 1670 this_cmd = FALSE;
1671 next_cmd = FALSE;
f842b64e 1672 } else if ((nscp_cmndinfo->phase & 0xff) == SCSIRAWSERVICE) {
45f1a41b 1673 if (!(cmd_index=gdth_fill_raw_cmd(ha, nscp, BUS_L2P(ha, b))))
1da177e4
LT		 1674 this_cmd = FALSE;
1675 next_cmd = FALSE;
1676 } else {
1677 memset((char*)nscp->sense_buffer,0,16);
1678 nscp->sense_buffer[0] = 0x70;
1679 nscp->sense_buffer[2] = NOT_READY;
1680 nscp->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
f842b64e
BH		 1681 if (!nscp_cmndinfo->wait_for_completion)
1682 nscp_cmndinfo->wait_for_completion++;
1da177e4 1683 else
b8bff2ae 1684 gdth_scsi_done(nscp);
1da177e4 1685 }
3058d5de 1686 } else if (gdth_cmnd_priv(nscp)->internal_command) {
45f1a41b 1687 if (!(cmd_index=gdth_special_cmd(ha, nscp)))
1da177e4
LT		 1688 this_cmd = FALSE;
1689 next_cmd = FALSE;
1690 } else if (b != ha->virt_bus) {
1691 if (ha->raw[BUS_L2P(ha,b)].io_cnt[t] >= GDTH_MAX_RAW ||
45f1a41b 1692 !(cmd_index=gdth_fill_raw_cmd(ha, nscp, BUS_L2P(ha, b))))
1da177e4
LT		 1693 this_cmd = FALSE;
1694 else
1695 ha->raw[BUS_L2P(ha,b)].io_cnt[t]++;
1696 } else if (t >= MAX_HDRIVES || !ha->hdr[t].present || l != 0) {
1697 TRACE2(("Command 0x%x to bus %d id %d lun %d -> IGNORE\n",
1698 nscp->cmnd[0], b, t, l));
1699 nscp->result = DID_BAD_TARGET << 16;
f842b64e
BH		 1700 if (!nscp_cmndinfo->wait_for_completion)
1701 nscp_cmndinfo->wait_for_completion++;
1da177e4 1702 else
b8bff2ae 1703 gdth_scsi_done(nscp);
1da177e4
LT		 1704 } else {
1705 switch (nscp->cmnd[0]) {
1706 case TEST_UNIT_READY:
1707 case INQUIRY:
1708 case REQUEST_SENSE:
1709 case READ_CAPACITY:
1710 case VERIFY:
1711 case START_STOP:
1712 case MODE_SENSE:
eb846d9f 1713 case SERVICE_ACTION_IN_16:
1da177e4
LT		 1714 TRACE(("cache cmd %x/%x/%x/%x/%x/%x\n",nscp->cmnd[0],
1715 nscp->cmnd[1],nscp->cmnd[2],nscp->cmnd[3],
1716 nscp->cmnd[4],nscp->cmnd[5]));
1717 if (ha->hdr[t].media_changed && nscp->cmnd[0] != INQUIRY) {
1718 /* return UNIT_ATTENTION */
1719 TRACE2(("cmd 0x%x target %d: UNIT_ATTENTION\n",
1720 nscp->cmnd[0], t));
1721 ha->hdr[t].media_changed = FALSE;
1722 memset((char*)nscp->sense_buffer,0,16);
1723 nscp->sense_buffer[0] = 0x70;
1724 nscp->sense_buffer[2] = UNIT_ATTENTION;
1725 nscp->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
f842b64e
BH		 1726 if (!nscp_cmndinfo->wait_for_completion)
1727 nscp_cmndinfo->wait_for_completion++;
1da177e4 1728 else
b8bff2ae 1729 gdth_scsi_done(nscp);
45f1a41b 1730 } else if (gdth_internal_cache_cmd(ha, nscp))
b8bff2ae 1731 gdth_scsi_done(nscp);
1da177e4
LT		 1732 break;
1733
1734 case ALLOW_MEDIUM_REMOVAL:
1735 TRACE(("cache cmd %x/%x/%x/%x/%x/%x\n",nscp->cmnd[0],
1736 nscp->cmnd[1],nscp->cmnd[2],nscp->cmnd[3],
1737 nscp->cmnd[4],nscp->cmnd[5]));
1738 if ( (nscp->cmnd[4]&1) && !(ha->hdr[t].devtype&1) ) {
1739 TRACE(("Prevent r. nonremov. drive->do nothing\n"));
1740 nscp->result = DID_OK << 16;
1741 nscp->sense_buffer[0] = 0;
f842b64e
BH		 1742 if (!nscp_cmndinfo->wait_for_completion)
1743 nscp_cmndinfo->wait_for_completion++;
1da177e4 1744 else
b8bff2ae 1745 gdth_scsi_done(nscp);
1da177e4
LT		 1746 } else {
1747 nscp->cmnd[3] = (ha->hdr[t].devtype&1) ? 1:0;
1748 TRACE(("Prevent/allow r. %d rem. drive %d\n",
1749 nscp->cmnd[4],nscp->cmnd[3]));
45f1a41b 1750 if (!(cmd_index=gdth_fill_cache_cmd(ha, nscp, t)))
1da177e4
LT		 1751 this_cmd = FALSE;
1752 }
1753 break;
1754
1755 case RESERVE:
1756 case RELEASE:
1757 TRACE2(("cache cmd %s\n",nscp->cmnd[0] == RESERVE ?
1758 "RESERVE" : "RELEASE"));
45f1a41b 1759 if (!(cmd_index=gdth_fill_cache_cmd(ha, nscp, t)))
1da177e4
LT		 1760 this_cmd = FALSE;
1761 break;
1762
1763 case READ_6:
1764 case WRITE_6:
1765 case READ_10:
1766 case WRITE_10:
1767 case READ_16:
1768 case WRITE_16:
1769 if (ha->hdr[t].media_changed) {
1770 /* return UNIT_ATTENTION */
1771 TRACE2(("cmd 0x%x target %d: UNIT_ATTENTION\n",
1772 nscp->cmnd[0], t));
1773 ha->hdr[t].media_changed = FALSE;
1774 memset((char*)nscp->sense_buffer,0,16);
1775 nscp->sense_buffer[0] = 0x70;
1776 nscp->sense_buffer[2] = UNIT_ATTENTION;
1777 nscp->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
f842b64e
BH		 1778 if (!nscp_cmndinfo->wait_for_completion)
1779 nscp_cmndinfo->wait_for_completion++;
1da177e4 1780 else
b8bff2ae 1781 gdth_scsi_done(nscp);
45f1a41b 1782 } else if (!(cmd_index=gdth_fill_cache_cmd(ha, nscp, t)))
1da177e4
LT		 1783 this_cmd = FALSE;
1784 break;
1785
1786 default:
1787 TRACE2(("cache cmd %x/%x/%x/%x/%x/%x unknown\n",nscp->cmnd[0],
1788 nscp->cmnd[1],nscp->cmnd[2],nscp->cmnd[3],
1789 nscp->cmnd[4],nscp->cmnd[5]));
1790 printk("GDT-HA %d: Unknown SCSI command 0x%x to cache service !\n",
45f1a41b 1791 ha->hanum, nscp->cmnd[0]);
1da177e4 1792 nscp->result = DID_ABORT << 16;
f842b64e
BH		 1793 if (!nscp_cmndinfo->wait_for_completion)
1794 nscp_cmndinfo->wait_for_completion++;
1da177e4 1795 else
b8bff2ae 1796 gdth_scsi_done(nscp);
1da177e4
LT		 1797 break;
1798 }
1799 }
1800
1801 if (!this_cmd)
1802 break;
1803 if (nscp == ha->req_first)
91ebc1fa 1804 ha->req_first = pscp = (struct scsi_cmnd *)nscp->SCp.ptr;
1da177e4
LT		 1805 else
1806 pscp->SCp.ptr = nscp->SCp.ptr;
1807 if (!next_cmd)
1808 break;
1809 }
1810
1811 if (ha->cmd_cnt > 0) {
45f1a41b 1812 gdth_release_event(ha);
1da177e4
LT		 1813 }
1814
1815 if (!gdth_polling)
1816 spin_unlock_irqrestore(&ha->smp_lock, flags);
1817
1818 if (gdth_polling && ha->cmd_cnt > 0) {
45f1a41b 1819 if (!gdth_wait(ha, cmd_index, POLL_TIMEOUT))
1da177e4 1820 printk("GDT-HA %d: Command %d timed out !\n",
45f1a41b 1821 ha->hanum, cmd_index);
1da177e4
LT		 1822 }
1823}
3892d88a
BH		 1824
1825/*
1826 * gdth_copy_internal_data() - copy to/from a buffer onto a scsi_cmnd's
1827 * buffers, kmap_atomic() as needed.
1828 */
91ebc1fa 1829static void gdth_copy_internal_data(gdth_ha_str *ha, struct scsi_cmnd *scp,
1fe6dbf4 1830 char *buffer, u16 count)
1da177e4 1831{
1fe6dbf4
DJ		 1832 u16 cpcount,i, max_sg = scsi_sg_count(scp);
1833 u16 cpsum,cpnow;
1da177e4 1834 struct scatterlist *sl;
1da177e4
LT		 1835 char *address;
1836
1fe6dbf4 1837 cpcount = min_t(u16, count, scsi_bufflen(scp));
1da177e4 1838
3892d88a
BH		 1839 if (cpcount) {
1840 cpsum=0;
1841 scsi_for_each_sg(scp, sl, max_sg, i) {
cbd5f69b 1842 unsigned long flags;
1fe6dbf4 1843 cpnow = (u16)sl->length;
1da177e4 1844 TRACE(("copy_internal() now %d sum %d count %d %d\n",
d35055a0 1845 cpnow, cpsum, cpcount, scsi_bufflen(scp)));
1da177e4
LT		 1846 if (cpsum+cpnow > cpcount)
1847 cpnow = cpcount - cpsum;
1848 cpsum += cpnow;
45711f1a 1849 if (!sg_page(sl)) {
1da177e4 1850 printk("GDT-HA %d: invalid sc/gt element in gdth_copy_internal_data()\n",
45f1a41b 1851 ha->hanum);
1da177e4
LT		 1852 return;
1853 }
cbd5f69b 1854 local_irq_save(flags);
77dfce07 1855 address = kmap_atomic(sg_page(sl)) + sl->offset;
ee54cc6a 1856 memcpy(address, buffer, cpnow);
45711f1a 1857 flush_dcache_page(sg_page(sl));
77dfce07 1858 kunmap_atomic(address);
cbd5f69b 1859 local_irq_restore(flags);
1da177e4
LT		 1860 if (cpsum == cpcount)
1861 break;
1862 buffer += cpnow;
1863 }
3892d88a
BH		 1864 } else if (count) {
1865 printk("GDT-HA %d: SCSI command with no buffers but data transfer expected!\n",
1866 ha->hanum);
1867 WARN_ON(1);
1da177e4
LT		 1868 }
1869}
1870
91ebc1fa 1871static int gdth_internal_cache_cmd(gdth_ha_str *ha, struct scsi_cmnd *scp)
1da177e4 1872{
1fe6dbf4 1873 u8 t;
1da177e4
LT		 1874 gdth_inq_data inq;
1875 gdth_rdcap_data rdc;
1876 gdth_sense_data sd;
1877 gdth_modep_data mpd;
f842b64e 1878 struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
1da177e4 1879
1da177e4
LT		 1880 t = scp->device->id;
1881 TRACE(("gdth_internal_cache_cmd() cmd 0x%x hdrive %d\n",
1882 scp->cmnd[0],t));
1883
1884 scp->result = DID_OK << 16;
1885 scp->sense_buffer[0] = 0;
1886
1887 switch (scp->cmnd[0]) {
1888 case TEST_UNIT_READY:
1889 case VERIFY:
1890 case START_STOP:
1891 TRACE2(("Test/Verify/Start hdrive %d\n",t));
1892 break;
1893
1894 case INQUIRY:
1895 TRACE2(("Inquiry hdrive %d devtype %d\n",
1896 t,ha->hdr[t].devtype));
1897 inq.type_qual = (ha->hdr[t].devtype&4) ? TYPE_ROM:TYPE_DISK;
1898 /* you can here set all disks to removable, if you want to do
1899 a flush using the ALLOW_MEDIUM_REMOVAL command */
1900 inq.modif_rmb = 0x00;
1901 if ((ha->hdr[t].devtype & 1) ||
1902 (ha->hdr[t].cluster_type & CLUSTER_DRIVE))
1903 inq.modif_rmb = 0x80;
1904 inq.version = 2;
1905 inq.resp_aenc = 2;
1906 inq.add_length= 32;
1907 strcpy(inq.vendor,ha->oem_name);
0606ffe2 1908 snprintf(inq.product, sizeof(inq.product), "Host Drive #%02d",t);
1da177e4 1909 strcpy(inq.revision," ");
ee54cc6a 1910 gdth_copy_internal_data(ha, scp, (char*)&inq, sizeof(gdth_inq_data));
1da177e4
LT		 1911 break;
1912
1913 case REQUEST_SENSE:
1914 TRACE2(("Request sense hdrive %d\n",t));
1915 sd.errorcode = 0x70;
1916 sd.segno = 0x00;
1917 sd.key = NO_SENSE;
1918 sd.info = 0;
1919 sd.add_length= 0;
ee54cc6a 1920 gdth_copy_internal_data(ha, scp, (char*)&sd, sizeof(gdth_sense_data));
1da177e4
LT		 1921 break;
1922
1923 case MODE_SENSE:
1924 TRACE2(("Mode sense hdrive %d\n",t));
1925 memset((char*)&mpd,0,sizeof(gdth_modep_data));
1926 mpd.hd.data_length = sizeof(gdth_modep_data);
1927 mpd.hd.dev_par = (ha->hdr[t].devtype&2) ? 0x80:0;
1928 mpd.hd.bd_length = sizeof(mpd.bd);
1929 mpd.bd.block_length[0] = (SECTOR_SIZE & 0x00ff0000) >> 16;
1930 mpd.bd.block_length[1] = (SECTOR_SIZE & 0x0000ff00) >> 8;
1931 mpd.bd.block_length[2] = (SECTOR_SIZE & 0x000000ff);
ee54cc6a 1932 gdth_copy_internal_data(ha, scp, (char*)&mpd, sizeof(gdth_modep_data));
1da177e4
LT		 1933 break;
1934
1935 case READ_CAPACITY:
1936 TRACE2(("Read capacity hdrive %d\n",t));
1fe6dbf4 1937 if (ha->hdr[t].size > (u64)0xffffffff)
1da177e4
LT		 1938 rdc.last_block_no = 0xffffffff;
1939 else
1940 rdc.last_block_no = cpu_to_be32(ha->hdr[t].size-1);
1941 rdc.block_length = cpu_to_be32(SECTOR_SIZE);
ee54cc6a 1942 gdth_copy_internal_data(ha, scp, (char*)&rdc, sizeof(gdth_rdcap_data));
1da177e4
LT		 1943 break;
1944
eb846d9f 1945 case SERVICE_ACTION_IN_16:
1da177e4
LT		 1946 if ((scp->cmnd[1] & 0x1f) == SAI_READ_CAPACITY_16 &&
1947 (ha->cache_feat & GDT_64BIT)) {
1948 gdth_rdcap16_data rdc16;
1949
1950 TRACE2(("Read capacity (16) hdrive %d\n",t));
1951 rdc16.last_block_no = cpu_to_be64(ha->hdr[t].size-1);
1952 rdc16.block_length = cpu_to_be32(SECTOR_SIZE);
45f1a41b 1953 gdth_copy_internal_data(ha, scp, (char*)&rdc16,
ee54cc6a 1954 sizeof(gdth_rdcap16_data));
1da177e4
LT		 1955 } else {
1956 scp->result = DID_ABORT << 16;
1957 }
1958 break;
1959
1960 default:
1961 TRACE2(("Internal cache cmd 0x%x unknown\n",scp->cmnd[0]));
1962 break;
1963 }
1964
f842b64e
BH		 1965 if (!cmndinfo->wait_for_completion)
1966 cmndinfo->wait_for_completion++;
1da177e4
LT		 1967 else
1968 return 1;
1969
1970 return 0;
1971}
45f1a41b 1972
91ebc1fa
JT		 1973static int gdth_fill_cache_cmd(gdth_ha_str *ha, struct scsi_cmnd *scp,
1974 u16 hdrive)
1da177e4 1975{
1da177e4 1976 register gdth_cmd_str *cmdp;
f842b64e 1977 struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
1fe6dbf4
DJ		 1978 u32 cnt, blockcnt;
1979 u64 no, blockno;
1da177e4 1980 int i, cmd_index, read_write, sgcnt, mode64;
1da177e4 1981
1da177e4
LT		 1982 cmdp = ha->pccb;
1983 TRACE(("gdth_fill_cache_cmd() cmd 0x%x cmdsize %d hdrive %d\n",
1984 scp->cmnd[0],scp->cmd_len,hdrive));
1985
1da177e4
LT		 1986 mode64 = (ha->cache_feat & GDT_64BIT) ? TRUE : FALSE;
1987 /* test for READ_16, WRITE_16 if !mode64 ? ---
1988 not required, should not occur due to error return on
1989 READ_CAPACITY_16 */
1990
1991 cmdp->Service = CACHESERVICE;
1992 cmdp->RequestBuffer = scp;
1993 /* search free command index */
45f1a41b 1994 if (!(cmd_index=gdth_get_cmd_index(ha))) {
1da177e4
LT		 1995 TRACE(("GDT: No free command index found\n"));
1996 return 0;
1997 }
1998 /* if it's the first command, set command semaphore */
1999 if (ha->cmd_cnt == 0)
45f1a41b 2000 gdth_set_sema0(ha);
1da177e4
LT		 2001
2002 /* fill command */
2003 read_write = 0;
f842b64e
BH		 2004 if (cmndinfo->OpCode != -1)
2005 cmdp->OpCode = cmndinfo->OpCode; /* special cache cmd. */
1da177e4
LT		 2006 else if (scp->cmnd[0] == RESERVE)
2007 cmdp->OpCode = GDT_RESERVE_DRV;
2008 else if (scp->cmnd[0] == RELEASE)
2009 cmdp->OpCode = GDT_RELEASE_DRV;
2010 else if (scp->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
2011 if (scp->cmnd[4] & 1) /* prevent ? */
2012 cmdp->OpCode = GDT_MOUNT;
2013 else if (scp->cmnd[3] & 1) /* removable drive ? */
2014 cmdp->OpCode = GDT_UNMOUNT;
2015 else
2016 cmdp->OpCode = GDT_FLUSH;
2017 } else if (scp->cmnd[0] == WRITE_6 || scp->cmnd[0] == WRITE_10 ||
2018 scp->cmnd[0] == WRITE_12 || scp->cmnd[0] == WRITE_16
2019 ) {
2020 read_write = 1;
2021 if (gdth_write_through || ((ha->hdr[hdrive].rw_attribs & 1) &&
2022 (ha->cache_feat & GDT_WR_THROUGH)))
2023 cmdp->OpCode = GDT_WRITE_THR;
2024 else
2025 cmdp->OpCode = GDT_WRITE;
2026 } else {
2027 read_write = 2;
2028 cmdp->OpCode = GDT_READ;
2029 }
2030
2031 cmdp->BoardNode = LOCALBOARD;
2032 if (mode64) {
2033 cmdp->u.cache64.DeviceNo = hdrive;
2034 cmdp->u.cache64.BlockNo = 1;
2035 cmdp->u.cache64.sg_canz = 0;
2036 } else {
2037 cmdp->u.cache.DeviceNo = hdrive;
2038 cmdp->u.cache.BlockNo = 1;
2039 cmdp->u.cache.sg_canz = 0;
2040 }
2041
2042 if (read_write) {
2043 if (scp->cmd_len == 16) {
1fe6dbf4 2044 memcpy(&no, &scp->cmnd[2], sizeof(u64));
1da177e4 2045 blockno = be64_to_cpu(no);
1fe6dbf4 2046 memcpy(&cnt, &scp->cmnd[10], sizeof(u32));
1da177e4
LT		 2047 blockcnt = be32_to_cpu(cnt);
2048 } else if (scp->cmd_len == 10) {
1fe6dbf4 2049 memcpy(&no, &scp->cmnd[2], sizeof(u32));
1da177e4 2050 blockno = be32_to_cpu(no);
1fe6dbf4 2051 memcpy(&cnt, &scp->cmnd[7], sizeof(u16));
1da177e4
LT		 2052 blockcnt = be16_to_cpu(cnt);
2053 } else {
1fe6dbf4 2054 memcpy(&no, &scp->cmnd[0], sizeof(u32));
1da177e4
LT		 2055 blockno = be32_to_cpu(no) & 0x001fffffUL;
2056 blockcnt= scp->cmnd[4]==0 ? 0x100 : scp->cmnd[4];
2057 }
2058 if (mode64) {
2059 cmdp->u.cache64.BlockNo = blockno;
2060 cmdp->u.cache64.BlockCnt = blockcnt;
2061 } else {
1fe6dbf4 2062 cmdp->u.cache.BlockNo = (u32)blockno;
1da177e4
LT		 2063 cmdp->u.cache.BlockCnt = blockcnt;
2064 }
2065
d35055a0 2066 if (scsi_bufflen(scp)) {
f842b64e 2067 cmndinfo->dma_dir = (read_write == 1 ?
bb327df8
CH		 2068 DMA_TO_DEVICE : DMA_FROM_DEVICE);
2069 sgcnt = dma_map_sg(&ha->pdev->dev, scsi_sglist(scp),
2070 scsi_sg_count(scp), cmndinfo->dma_dir);
1da177e4 2071 if (mode64) {
3892d88a
BH		 2072 struct scatterlist *sl;
2073
1fe6dbf4 2074 cmdp->u.cache64.DestAddr= (u64)-1;
1da177e4 2075 cmdp->u.cache64.sg_canz = sgcnt;
3892d88a 2076 scsi_for_each_sg(scp, sl, sgcnt, i) {
1da177e4 2077 cmdp->u.cache64.sg_lst[i].sg_ptr = sg_dma_address(sl);
1da177e4
LT		 2078 cmdp->u.cache64.sg_lst[i].sg_len = sg_dma_len(sl);
2079 }
2080 } else {
3892d88a
BH		 2081 struct scatterlist *sl;
2082
1da177e4
LT		 2083 cmdp->u.cache.DestAddr= 0xffffffff;
2084 cmdp->u.cache.sg_canz = sgcnt;
3892d88a 2085 scsi_for_each_sg(scp, sl, sgcnt, i) {
1da177e4 2086 cmdp->u.cache.sg_lst[i].sg_ptr = sg_dma_address(sl);
1da177e4
LT		 2087 cmdp->u.cache.sg_lst[i].sg_len = sg_dma_len(sl);
2088 }
2089 }
2090
2091#ifdef GDTH_STATISTICS
1fe6dbf4
DJ		 2092 if (max_sg < (u32)sgcnt) {
2093 max_sg = (u32)sgcnt;
1da177e4
LT		 2094 TRACE3(("GDT: max_sg = %d\n",max_sg));
2095 }
2096#endif
2097
1da177e4
LT		 2098 }
2099 }
2100 /* evaluate command size, check space */
2101 if (mode64) {
2102 TRACE(("cache cmd: addr. %x sganz %x sgptr0 %x sglen0 %x\n",
2103 cmdp->u.cache64.DestAddr,cmdp->u.cache64.sg_canz,
2104 cmdp->u.cache64.sg_lst[0].sg_ptr,
2105 cmdp->u.cache64.sg_lst[0].sg_len));
2106 TRACE(("cache cmd: cmd %d blockno. %d, blockcnt %d\n",
2107 cmdp->OpCode,cmdp->u.cache64.BlockNo,cmdp->u.cache64.BlockCnt));
2108 ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.cache64.sg_lst) +
1fe6dbf4 2109 (u16)cmdp->u.cache64.sg_canz * sizeof(gdth_sg64_str);
1da177e4
LT		 2110 } else {
2111 TRACE(("cache cmd: addr. %x sganz %x sgptr0 %x sglen0 %x\n",
2112 cmdp->u.cache.DestAddr,cmdp->u.cache.sg_canz,
2113 cmdp->u.cache.sg_lst[0].sg_ptr,
2114 cmdp->u.cache.sg_lst[0].sg_len));
2115 TRACE(("cache cmd: cmd %d blockno. %d, blockcnt %d\n",
2116 cmdp->OpCode,cmdp->u.cache.BlockNo,cmdp->u.cache.BlockCnt));
2117 ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.cache.sg_lst) +
1fe6dbf4 2118 (u16)cmdp->u.cache.sg_canz * sizeof(gdth_sg_str);
1da177e4
LT		 2119 }
2120 if (ha->cmd_len & 3)
2121 ha->cmd_len += (4 - (ha->cmd_len & 3));
2122
2123 if (ha->cmd_cnt > 0) {
2124 if ((ha->cmd_offs_dpmem + ha->cmd_len + DPMEM_COMMAND_OFFSET) >
2125 ha->ic_all_size) {
2126 TRACE2(("gdth_fill_cache() DPMEM overflow\n"));
2127 ha->cmd_tab[cmd_index-2].cmnd = UNUSED_CMND;
2128 return 0;
2129 }
2130 }
2131
2132 /* copy command */
45f1a41b 2133 gdth_copy_command(ha);
1da177e4
LT		 2134 return cmd_index;
2135}
2136
91ebc1fa 2137static int gdth_fill_raw_cmd(gdth_ha_str *ha, struct scsi_cmnd *scp, u8 b)
1da177e4 2138{
1da177e4 2139 register gdth_cmd_str *cmdp;
1fe6dbf4 2140 u16 i;
3892d88a 2141 dma_addr_t sense_paddr;
1da177e4 2142 int cmd_index, sgcnt, mode64;
1fe6dbf4 2143 u8 t,l;
3058d5de 2144 struct gdth_cmndinfo *cmndinfo;
1da177e4 2145
1da177e4
LT		 2146 t = scp->device->id;
2147 l = scp->device->lun;
2148 cmdp = ha->pccb;
2149 TRACE(("gdth_fill_raw_cmd() cmd 0x%x bus %d ID %d LUN %d\n",
2150 scp->cmnd[0],b,t,l));
2151
1da177e4
LT		 2152 mode64 = (ha->raw_feat & GDT_64BIT) ? TRUE : FALSE;
2153
2154 cmdp->Service = SCSIRAWSERVICE;
2155 cmdp->RequestBuffer = scp;
2156 /* search free command index */
45f1a41b 2157 if (!(cmd_index=gdth_get_cmd_index(ha))) {
1da177e4
LT		 2158 TRACE(("GDT: No free command index found\n"));
2159 return 0;
2160 }
2161 /* if it's the first command, set command semaphore */
2162 if (ha->cmd_cnt == 0)
45f1a41b 2163 gdth_set_sema0(ha);
1da177e4 2164
3058d5de 2165 cmndinfo = gdth_cmnd_priv(scp);
1da177e4 2166 /* fill command */
f842b64e
BH		 2167 if (cmndinfo->OpCode != -1) {
2168 cmdp->OpCode = cmndinfo->OpCode; /* special raw cmd. */
1da177e4
LT		 2169 cmdp->BoardNode = LOCALBOARD;
2170 if (mode64) {
f842b64e 2171 cmdp->u.raw64.direction = (cmndinfo->phase >> 8);
1da177e4
LT		 2172 TRACE2(("special raw cmd 0x%x param 0x%x\n",
2173 cmdp->OpCode, cmdp->u.raw64.direction));
2174 /* evaluate command size */
2175 ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.raw64.sg_lst);
2176 } else {
f842b64e 2177 cmdp->u.raw.direction = (cmndinfo->phase >> 8);
1da177e4
LT		 2178 TRACE2(("special raw cmd 0x%x param 0x%x\n",
2179 cmdp->OpCode, cmdp->u.raw.direction));
2180 /* evaluate command size */
2181 ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.raw.sg_lst);
2182 }
2183
2184 } else {
bb327df8
CH		 2185 sense_paddr = dma_map_single(&ha->pdev->dev, scp->sense_buffer, 16,
2186 DMA_FROM_DEVICE);
3058d5de
BH		 2187
2188 cmndinfo->sense_paddr = sense_paddr;
1da177e4
LT		 2189 cmdp->OpCode = GDT_WRITE; /* always */
2190 cmdp->BoardNode = LOCALBOARD;
2191 if (mode64) {
2192 cmdp->u.raw64.reserved = 0;
2193 cmdp->u.raw64.mdisc_time = 0;
2194 cmdp->u.raw64.mcon_time = 0;
2195 cmdp->u.raw64.clen = scp->cmd_len;
2196 cmdp->u.raw64.target = t;
2197 cmdp->u.raw64.lun = l;
2198 cmdp->u.raw64.bus = b;
2199 cmdp->u.raw64.priority = 0;
d35055a0 2200 cmdp->u.raw64.sdlen = scsi_bufflen(scp);
1da177e4
LT		 2201 cmdp->u.raw64.sense_len = 16;
2202 cmdp->u.raw64.sense_data = sense_paddr;
2203 cmdp->u.raw64.direction =
2204 gdth_direction_tab[scp->cmnd[0]]==DOU ? GDTH_DATA_OUT:GDTH_DATA_IN;
2205 memcpy(cmdp->u.raw64.cmd,scp->cmnd,16);
bb9ba31c 2206 cmdp->u.raw64.sg_ranz = 0;
1da177e4
LT		 2207 } else {
2208 cmdp->u.raw.reserved = 0;
2209 cmdp->u.raw.mdisc_time = 0;
2210 cmdp->u.raw.mcon_time = 0;
2211 cmdp->u.raw.clen = scp->cmd_len;
2212 cmdp->u.raw.target = t;
2213 cmdp->u.raw.lun = l;
2214 cmdp->u.raw.bus = b;
2215 cmdp->u.raw.priority = 0;
2216 cmdp->u.raw.link_p = 0;
d35055a0 2217 cmdp->u.raw.sdlen = scsi_bufflen(scp);
1da177e4
LT		 2218 cmdp->u.raw.sense_len = 16;
2219 cmdp->u.raw.sense_data = sense_paddr;
2220 cmdp->u.raw.direction =
2221 gdth_direction_tab[scp->cmnd[0]]==DOU ? GDTH_DATA_OUT:GDTH_DATA_IN;
2222 memcpy(cmdp->u.raw.cmd,scp->cmnd,12);
bb9ba31c 2223 cmdp->u.raw.sg_ranz = 0;
1da177e4
LT		 2224 }
2225
d35055a0 2226 if (scsi_bufflen(scp)) {
bb327df8
CH		 2227 cmndinfo->dma_dir = DMA_BIDIRECTIONAL;
2228 sgcnt = dma_map_sg(&ha->pdev->dev, scsi_sglist(scp),
2229 scsi_sg_count(scp), cmndinfo->dma_dir);
1da177e4 2230 if (mode64) {
3892d88a
BH		 2231 struct scatterlist *sl;
2232
1fe6dbf4 2233 cmdp->u.raw64.sdata = (u64)-1;
1da177e4 2234 cmdp->u.raw64.sg_ranz = sgcnt;
3892d88a 2235 scsi_for_each_sg(scp, sl, sgcnt, i) {
1da177e4 2236 cmdp->u.raw64.sg_lst[i].sg_ptr = sg_dma_address(sl);
1da177e4
LT		 2237 cmdp->u.raw64.sg_lst[i].sg_len = sg_dma_len(sl);
2238 }
2239 } else {
3892d88a
BH		 2240 struct scatterlist *sl;
2241
1da177e4
LT		 2242 cmdp->u.raw.sdata = 0xffffffff;
2243 cmdp->u.raw.sg_ranz = sgcnt;
3892d88a 2244 scsi_for_each_sg(scp, sl, sgcnt, i) {
1da177e4 2245 cmdp->u.raw.sg_lst[i].sg_ptr = sg_dma_address(sl);
1da177e4
LT		 2246 cmdp->u.raw.sg_lst[i].sg_len = sg_dma_len(sl);
2247 }
2248 }
2249
2250#ifdef GDTH_STATISTICS
2251 if (max_sg < sgcnt) {
2252 max_sg = sgcnt;
2253 TRACE3(("GDT: max_sg = %d\n",sgcnt));
2254 }
2255#endif
2256
1da177e4
LT		 2257 }
2258 if (mode64) {
2259 TRACE(("raw cmd: addr. %x sganz %x sgptr0 %x sglen0 %x\n",
2260 cmdp->u.raw64.sdata,cmdp->u.raw64.sg_ranz,
2261 cmdp->u.raw64.sg_lst[0].sg_ptr,
2262 cmdp->u.raw64.sg_lst[0].sg_len));
2263 /* evaluate command size */
2264 ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.raw64.sg_lst) +
1fe6dbf4 2265 (u16)cmdp->u.raw64.sg_ranz * sizeof(gdth_sg64_str);
1da177e4
LT		 2266 } else {
2267 TRACE(("raw cmd: addr. %x sganz %x sgptr0 %x sglen0 %x\n",
2268 cmdp->u.raw.sdata,cmdp->u.raw.sg_ranz,
2269 cmdp->u.raw.sg_lst[0].sg_ptr,
2270 cmdp->u.raw.sg_lst[0].sg_len));
2271 /* evaluate command size */
2272 ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.raw.sg_lst) +
1fe6dbf4 2273 (u16)cmdp->u.raw.sg_ranz * sizeof(gdth_sg_str);
1da177e4
LT		 2274 }
2275 }
2276 /* check space */
2277 if (ha->cmd_len & 3)
2278 ha->cmd_len += (4 - (ha->cmd_len & 3));
2279
2280 if (ha->cmd_cnt > 0) {
2281 if ((ha->cmd_offs_dpmem + ha->cmd_len + DPMEM_COMMAND_OFFSET) >
2282 ha->ic_all_size) {
2283 TRACE2(("gdth_fill_raw() DPMEM overflow\n"));
2284 ha->cmd_tab[cmd_index-2].cmnd = UNUSED_CMND;
2285 return 0;
2286 }
2287 }
2288
2289 /* copy command */
45f1a41b 2290 gdth_copy_command(ha);
1da177e4
LT		 2291 return cmd_index;
2292}
2293
91ebc1fa 2294static int gdth_special_cmd(gdth_ha_str *ha, struct scsi_cmnd *scp)
1da177e4 2295{
1da177e4 2296 register gdth_cmd_str *cmdp;
ee54cc6a 2297 struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
1da177e4
LT		 2298 int cmd_index;
2299
1da177e4
LT		 2300 cmdp= ha->pccb;
2301 TRACE2(("gdth_special_cmd(): "));
2302
ee54cc6a 2303 *cmdp = *cmndinfo->internal_cmd_str;
1da177e4
LT		 2304 cmdp->RequestBuffer = scp;
2305
2306 /* search free command index */
45f1a41b 2307 if (!(cmd_index=gdth_get_cmd_index(ha))) {
1da177e4
LT		 2308 TRACE(("GDT: No free command index found\n"));
2309 return 0;
2310 }
2311
2312 /* if it's the first command, set command semaphore */
2313 if (ha->cmd_cnt == 0)
45f1a41b 2314 gdth_set_sema0(ha);
1da177e4
LT		 2315
2316 /* evaluate command size, check space */
2317 if (cmdp->OpCode == GDT_IOCTL) {
2318 TRACE2(("IOCTL\n"));
2319 ha->cmd_len =
1fe6dbf4 2320 GDTOFFSOF(gdth_cmd_str,u.ioctl.p_param) + sizeof(u64);
1da177e4
LT		 2321 } else if (cmdp->Service == CACHESERVICE) {
2322 TRACE2(("cache command %d\n",cmdp->OpCode));
2323 if (ha->cache_feat & GDT_64BIT)
2324 ha->cmd_len =
2325 GDTOFFSOF(gdth_cmd_str,u.cache64.sg_lst) + sizeof(gdth_sg64_str);
2326 else
2327 ha->cmd_len =
2328 GDTOFFSOF(gdth_cmd_str,u.cache.sg_lst) + sizeof(gdth_sg_str);
2329 } else if (cmdp->Service == SCSIRAWSERVICE) {
2330 TRACE2(("raw command %d\n",cmdp->OpCode));
2331 if (ha->raw_feat & GDT_64BIT)
2332 ha->cmd_len =
2333 GDTOFFSOF(gdth_cmd_str,u.raw64.sg_lst) + sizeof(gdth_sg64_str);
2334 else
2335 ha->cmd_len =
2336 GDTOFFSOF(gdth_cmd_str,u.raw.sg_lst) + sizeof(gdth_sg_str);
2337 }
2338
2339 if (ha->cmd_len & 3)
2340 ha->cmd_len += (4 - (ha->cmd_len & 3));
2341
2342 if (ha->cmd_cnt > 0) {
2343 if ((ha->cmd_offs_dpmem + ha->cmd_len + DPMEM_COMMAND_OFFSET) >
2344 ha->ic_all_size) {
2345 TRACE2(("gdth_special_cmd() DPMEM overflow\n"));
2346 ha->cmd_tab[cmd_index-2].cmnd = UNUSED_CMND;
2347 return 0;
2348 }
2349 }
2350
2351 /* copy command */
45f1a41b 2352 gdth_copy_command(ha);
1da177e4
LT		 2353 return cmd_index;
2354}
2355
2356
2357/* Controller event handling functions */
1fe6dbf4
DJ		 2358static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, u16 source,
2359 u16 idx, gdth_evt_data *evt)
1da177e4
LT		 2360{
2361 gdth_evt_str *e;
1da177e4
LT		 2362
2363 /* no GDTH_LOCK_HA() ! */
2364 TRACE2(("gdth_store_event() source %d idx %d\n", source, idx));
2365 if (source == 0) /* no source -> no event */
2366 return NULL;
2367
2368 if (ebuffer[elastidx].event_source == source &&
2369 ebuffer[elastidx].event_idx == idx &&
2370 ((evt->size != 0 && ebuffer[elastidx].event_data.size != 0 &&
2371 !memcmp((char *)&ebuffer[elastidx].event_data.eu,
2372 (char *)&evt->eu, evt->size)) ||
2373 (evt->size == 0 && ebuffer[elastidx].event_data.size == 0 &&
2374 !strcmp((char *)&ebuffer[elastidx].event_data.event_string,
2375 (char *)&evt->event_string)))) {
2376 e = &ebuffer[elastidx];
5a412c38 2377 e->last_stamp = (u32)ktime_get_real_seconds();
1da177e4
LT		 2378 ++e->same_count;
2379 } else {
2380 if (ebuffer[elastidx].event_source != 0) { /* entry not free ? */
2381 ++elastidx;
2382 if (elastidx == MAX_EVENTS)
2383 elastidx = 0;
2384 if (elastidx == eoldidx) { /* reached mark ? */
2385 ++eoldidx;
2386 if (eoldidx == MAX_EVENTS)
2387 eoldidx = 0;
2388 }
2389 }
2390 e = &ebuffer[elastidx];
2391 e->event_source = source;
2392 e->event_idx = idx;
5a412c38 2393 e->first_stamp = e->last_stamp = (u32)ktime_get_real_seconds();
1da177e4
LT		 2394 e->same_count = 1;
2395 e->event_data = *evt;
2396 e->application = 0;
2397 }
2398 return e;
2399}
2400
2401static int gdth_read_event(gdth_ha_str *ha, int handle, gdth_evt_str *estr)
2402{
2403 gdth_evt_str *e;
2404 int eindex;
1fe6dbf4 2405 unsigned long flags;
1da177e4
LT		 2406
2407 TRACE2(("gdth_read_event() handle %d\n", handle));
2408 spin_lock_irqsave(&ha->smp_lock, flags);
2409 if (handle == -1)
2410 eindex = eoldidx;
2411 else
2412 eindex = handle;
2413 estr->event_source = 0;
2414
690e7448 2415 if (eindex < 0 || eindex >= MAX_EVENTS) {
1da177e4
LT		 2416 spin_unlock_irqrestore(&ha->smp_lock, flags);
2417 return eindex;
2418 }
2419 e = &ebuffer[eindex];
2420 if (e->event_source != 0) {
2421 if (eindex != elastidx) {
2422 if (++eindex == MAX_EVENTS)
2423 eindex = 0;
2424 } else {
2425 eindex = -1;
2426 }
2427 memcpy(estr, e, sizeof(gdth_evt_str));
2428 }
2429 spin_unlock_irqrestore(&ha->smp_lock, flags);
2430 return eindex;
2431}
2432
2433static void gdth_readapp_event(gdth_ha_str *ha,
1fe6dbf4 2434 u8 application, gdth_evt_str *estr)
1da177e4
LT		 2435{
2436 gdth_evt_str *e;
2437 int eindex;
1fe6dbf4
DJ		 2438 unsigned long flags;
2439 u8 found = FALSE;
1da177e4
LT		 2440
2441 TRACE2(("gdth_readapp_event() app. %d\n", application));
2442 spin_lock_irqsave(&ha->smp_lock, flags);
2443 eindex = eoldidx;
2444 for (;;) {
2445 e = &ebuffer[eindex];
2446 if (e->event_source == 0)
2447 break;
2448 if ((e->application & application) == 0) {
2449 e->application |= application;
2450 found = TRUE;
2451 break;
2452 }
2453 if (eindex == elastidx)
2454 break;
2455 if (++eindex == MAX_EVENTS)
2456 eindex = 0;
2457 }
2458 if (found)
2459 memcpy(estr, e, sizeof(gdth_evt_str));
2460 else
2461 estr->event_source = 0;
2462 spin_unlock_irqrestore(&ha->smp_lock, flags);
2463}
2464
2465static void gdth_clear_events(void)
2466{
2467 TRACE(("gdth_clear_events()"));
2468
2469 eoldidx = elastidx = 0;
2470 ebuffer[0].event_source = 0;
2471}
2472
2473
2474/* SCSI interface functions */
2475
230e886e 2476static irqreturn_t __gdth_interrupt(gdth_ha_str *ha,
10e1b4bc 2477 int gdth_from_wait, int* pIndex)
1da177e4 2478{
1da177e4
LT		 2479 gdt6m_dpram_str __iomem *dp6m_ptr = NULL;
2480 gdt6_dpram_str __iomem *dp6_ptr;
91ebc1fa 2481 struct scsi_cmnd *scp;
10e1b4bc 2482 int rval, i;
1fe6dbf4
DJ		 2483 u8 IStatus;
2484 u16 Service;
2485 unsigned long flags = 0;
1da177e4 2486
230e886e 2487 TRACE(("gdth_interrupt() IRQ %d\n", ha->irq));
1da177e4
LT		 2488
2489 /* if polling and not from gdth_wait() -> return */
2490 if (gdth_polling) {
2491 if (!gdth_from_wait) {
2492 return IRQ_HANDLED;
2493 }
2494 }
2495
2496 if (!gdth_polling)
10e1b4bc 2497 spin_lock_irqsave(&ha->smp_lock, flags);
1da177e4
LT		 2498
2499 /* search controller */
230e886e
JG		 2500 IStatus = gdth_get_status(ha);
2501 if (IStatus == 0) {
1da177e4
LT		 2502 /* spurious interrupt */
2503 if (!gdth_polling)
10e1b4bc
BH		 2504 spin_unlock_irqrestore(&ha->smp_lock, flags);
2505 return IRQ_HANDLED;
1da177e4 2506 }
1da177e4
LT		 2507
2508#ifdef GDTH_STATISTICS
2509 ++act_ints;
2510#endif
2511
31481455 2512 if (ha->type == GDT_PCI) {
1da177e4
LT		 2513 dp6_ptr = ha->brd;
2514 if (IStatus & 0x80) { /* error flag */
2515 IStatus &= ~0x80;
a52667f3 2516 ha->status = readw(&dp6_ptr->u.ic.Status);
1da177e4
LT		 2517 TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,ha->status));
2518 } else /* no error */
2519 ha->status = S_OK;
a52667f3
JG		 2520 ha->info = readl(&dp6_ptr->u.ic.Info[0]);
2521 ha->service = readw(&dp6_ptr->u.ic.Service);
2522 ha->info2 = readl(&dp6_ptr->u.ic.Info[1]);
1da177e4 2523
a52667f3
JG		 2524 writeb(0xff, &dp6_ptr->io.irqdel); /* acknowledge interrupt */
2525 writeb(0, &dp6_ptr->u.ic.Cmd_Index);/* reset command index */
2526 writeb(0, &dp6_ptr->io.Sema1); /* reset status semaphore */
1da177e4
LT		 2527 } else if (ha->type == GDT_PCINEW) {
2528 if (IStatus & 0x80) { /* error flag */
2529 IStatus &= ~0x80;
2530 ha->status = inw(PTR2USHORT(&ha->plx->status));
2531 TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,ha->status));
2532 } else
2533 ha->status = S_OK;
2534 ha->info = inl(PTR2USHORT(&ha->plx->info[0]));
2535 ha->service = inw(PTR2USHORT(&ha->plx->service));
2536 ha->info2 = inl(PTR2USHORT(&ha->plx->info[1]));
2537
2538 outb(0xff, PTR2USHORT(&ha->plx->edoor_reg));
2539 outb(0x00, PTR2USHORT(&ha->plx->sema1_reg));
2540 } else if (ha->type == GDT_PCIMPR) {
2541 dp6m_ptr = ha->brd;
2542 if (IStatus & 0x80) { /* error flag */
2543 IStatus &= ~0x80;
d8e1e6ad 2544 ha->status = readw(&dp6m_ptr->i960r.status);
1da177e4
LT		 2545 TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,ha->status));
2546 } else /* no error */
2547 ha->status = S_OK;
d8e1e6ad
CH		 2548
2549 ha->info = readl(&dp6m_ptr->i960r.info[0]);
2550 ha->service = readw(&dp6m_ptr->i960r.service);
2551 ha->info2 = readl(&dp6m_ptr->i960r.info[1]);
2552
1da177e4
LT		 2553 /* event string */
2554 if (IStatus == ASYNCINDEX) {
2555 if (ha->service != SCREENSERVICE &&
2556 (ha->fw_vers & 0xff) >= 0x1a) {
a52667f3 2557 ha->dvr.severity = readb
1da177e4
LT		 2558 (&((gdt6m_dpram_str __iomem *)ha->brd)->i960r.severity);
2559 for (i = 0; i < 256; ++i) {
a52667f3 2560 ha->dvr.event_string[i] = readb
1da177e4
LT		 2561 (&((gdt6m_dpram_str __iomem *)ha->brd)->i960r.evt_str[i]);
2562 if (ha->dvr.event_string[i] == 0)
2563 break;
2564 }
2565 }
2566 }
d8e1e6ad
CH		 2567 writeb(0xff, &dp6m_ptr->i960r.edoor_reg);
2568 writeb(0, &dp6m_ptr->i960r.sema1_reg);
1da177e4
LT		 2569 } else {
2570 TRACE2(("gdth_interrupt() unknown controller type\n"));
2571 if (!gdth_polling)
10e1b4bc 2572 spin_unlock_irqrestore(&ha->smp_lock, flags);
1da177e4
LT		 2573 return IRQ_HANDLED;
2574 }
2575
2576 TRACE(("gdth_interrupt() index %d stat %d info %d\n",
2577 IStatus,ha->status,ha->info));
2578
2579 if (gdth_from_wait) {
10e1b4bc 2580 *pIndex = (int)IStatus;
1da177e4
LT		 2581 }
2582
2583 if (IStatus == ASYNCINDEX) {
2584 TRACE2(("gdth_interrupt() async. event\n"));
45f1a41b 2585 gdth_async_event(ha);
1da177e4 2586 if (!gdth_polling)
10e1b4bc 2587 spin_unlock_irqrestore(&ha->smp_lock, flags);
45f1a41b 2588 gdth_next(ha);
1da177e4
LT		 2589 return IRQ_HANDLED;
2590 }
2591
2592 if (IStatus == SPEZINDEX) {
2593 TRACE2(("Service unknown or not initialized !\n"));
2594 ha->dvr.size = sizeof(ha->dvr.eu.driver);
10e1b4bc 2595 ha->dvr.eu.driver.ionode = ha->hanum;
1da177e4
LT		 2596 gdth_store_event(ha, ES_DRIVER, 4, &ha->dvr);
2597 if (!gdth_polling)
10e1b4bc 2598 spin_unlock_irqrestore(&ha->smp_lock, flags);
1da177e4
LT		 2599 return IRQ_HANDLED;
2600 }
2601 scp = ha->cmd_tab[IStatus-2].cmnd;
2602 Service = ha->cmd_tab[IStatus-2].service;
2603 ha->cmd_tab[IStatus-2].cmnd = UNUSED_CMND;
2604 if (scp == UNUSED_CMND) {
2605 TRACE2(("gdth_interrupt() index to unused command (%d)\n",IStatus));
2606 ha->dvr.size = sizeof(ha->dvr.eu.driver);
10e1b4bc 2607 ha->dvr.eu.driver.ionode = ha->hanum;
1da177e4
LT		 2608 ha->dvr.eu.driver.index = IStatus;
2609 gdth_store_event(ha, ES_DRIVER, 1, &ha->dvr);
2610 if (!gdth_polling)
10e1b4bc 2611 spin_unlock_irqrestore(&ha->smp_lock, flags);
1da177e4
LT		 2612 return IRQ_HANDLED;
2613 }
2614 if (scp == INTERNAL_CMND) {
2615 TRACE(("gdth_interrupt() answer to internal command\n"));
2616 if (!gdth_polling)
10e1b4bc 2617 spin_unlock_irqrestore(&ha->smp_lock, flags);
1da177e4
LT		 2618 return IRQ_HANDLED;
2619 }
2620
2621 TRACE(("gdth_interrupt() sync. status\n"));
45f1a41b 2622 rval = gdth_sync_event(ha,Service,IStatus,scp);
1da177e4 2623 if (!gdth_polling)
10e1b4bc 2624 spin_unlock_irqrestore(&ha->smp_lock, flags);
1da177e4 2625 if (rval == 2) {
f842b64e 2626 gdth_putq(ha, scp, gdth_cmnd_priv(scp)->priority);
1da177e4 2627 } else if (rval == 1) {
b8bff2ae 2628 gdth_scsi_done(scp);
1da177e4
LT		 2629 }
2630
45f1a41b 2631 gdth_next(ha);
1da177e4
LT		 2632 return IRQ_HANDLED;
2633}
2634
10e1b4bc
BH		 2635static irqreturn_t gdth_interrupt(int irq, void *dev_id)
2636{
230e886e 2637 gdth_ha_str *ha = dev_id;
10e1b4bc 2638
230e886e 2639 return __gdth_interrupt(ha, false, NULL);
10e1b4bc
BH		 2640}
2641
1fe6dbf4 2642static int gdth_sync_event(gdth_ha_str *ha, int service, u8 index,
91ebc1fa 2643 struct scsi_cmnd *scp)
1da177e4 2644{
1da177e4
LT		 2645 gdth_msg_str *msg;
2646 gdth_cmd_str *cmdp;
1fe6dbf4 2647 u8 b, t;
3058d5de 2648 struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
1da177e4 2649
1da177e4
LT		 2650 cmdp = ha->pccb;
2651 TRACE(("gdth_sync_event() serv %d status %d\n",
2652 service,ha->status));
2653
2654 if (service == SCREENSERVICE) {
2655 msg = ha->pmsg;
2656 TRACE(("len: %d, answer: %d, ext: %d, alen: %d\n",
2657 msg->msg_len,msg->msg_answer,msg->msg_ext,msg->msg_alen));
2658 if (msg->msg_len > MSGLEN+1)
2659 msg->msg_len = MSGLEN+1;
2660 if (msg->msg_len)
2661 if (!(msg->msg_answer && msg->msg_ext)) {
2662 msg->msg_text[msg->msg_len] = '\0';
2663 printk("%s",msg->msg_text);
2664 }
2665
2666 if (msg->msg_ext && !msg->msg_answer) {
45f1a41b 2667 while (gdth_test_busy(ha))
1da177e4
LT		 2668 gdth_delay(0);
2669 cmdp->Service = SCREENSERVICE;
2670 cmdp->RequestBuffer = SCREEN_CMND;
45f1a41b
BH		 2671 gdth_get_cmd_index(ha);
2672 gdth_set_sema0(ha);
1da177e4
LT		 2673 cmdp->OpCode = GDT_READ;
2674 cmdp->BoardNode = LOCALBOARD;
2675 cmdp->u.screen.reserved = 0;
2676 cmdp->u.screen.su.msg.msg_handle= msg->msg_handle;
2677 cmdp->u.screen.su.msg.msg_addr = ha->msg_phys;
2678 ha->cmd_offs_dpmem = 0;
2679 ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr)
1fe6dbf4 2680 + sizeof(u64);
1da177e4 2681 ha->cmd_cnt = 0;
45f1a41b
BH		 2682 gdth_copy_command(ha);
2683 gdth_release_event(ha);
1da177e4
LT		 2684 return 0;
2685 }
2686
2687 if (msg->msg_answer && msg->msg_alen) {
2688 /* default answers (getchar() not possible) */
2689 if (msg->msg_alen == 1) {
2690 msg->msg_alen = 0;
2691 msg->msg_len = 1;
2692 msg->msg_text[0] = 0;
2693 } else {
2694 msg->msg_alen -= 2;
2695 msg->msg_len = 2;
2696 msg->msg_text[0] = 1;
2697 msg->msg_text[1] = 0;
2698 }
2699 msg->msg_ext = 0;
2700 msg->msg_answer = 0;
45f1a41b 2701 while (gdth_test_busy(ha))
1da177e4
LT		 2702 gdth_delay(0);
2703 cmdp->Service = SCREENSERVICE;
2704 cmdp->RequestBuffer = SCREEN_CMND;
45f1a41b
BH		 2705 gdth_get_cmd_index(ha);
2706 gdth_set_sema0(ha);
1da177e4
LT		 2707 cmdp->OpCode = GDT_WRITE;
2708 cmdp->BoardNode = LOCALBOARD;
2709 cmdp->u.screen.reserved = 0;
2710 cmdp->u.screen.su.msg.msg_handle= msg->msg_handle;
2711 cmdp->u.screen.su.msg.msg_addr = ha->msg_phys;
2712 ha->cmd_offs_dpmem = 0;
2713 ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr)
1fe6dbf4 2714 + sizeof(u64);
1da177e4 2715 ha->cmd_cnt = 0;
45f1a41b
BH		 2716 gdth_copy_command(ha);
2717 gdth_release_event(ha);
1da177e4
LT		 2718 return 0;
2719 }
2720 printk("\n");
2721
2722 } else {
52759e6a 2723 b = scp->device->channel;
1da177e4 2724 t = scp->device->id;
f842b64e 2725 if (cmndinfo->OpCode == -1 && b != ha->virt_bus) {
1da177e4
LT		 2726 ha->raw[BUS_L2P(ha,b)].io_cnt[t]--;
2727 }
2728 /* cache or raw service */
2729 if (ha->status == S_BSY) {
2730 TRACE2(("Controller busy -> retry !\n"));
f842b64e
BH		 2731 if (cmndinfo->OpCode == GDT_MOUNT)
2732 cmndinfo->OpCode = GDT_CLUST_INFO;
1da177e4
LT		 2733 /* retry */
2734 return 2;
2735 }
d35055a0 2736 if (scsi_bufflen(scp))
bb327df8 2737 dma_unmap_sg(&ha->pdev->dev, scsi_sglist(scp), scsi_sg_count(scp),
3892d88a
BH		 2738 cmndinfo->dma_dir);
2739
3058d5de 2740 if (cmndinfo->sense_paddr)
bb327df8
CH		 2741 dma_unmap_page(&ha->pdev->dev, cmndinfo->sense_paddr, 16,
2742 DMA_FROM_DEVICE);
1da177e4
LT		 2743
2744 if (ha->status == S_OK) {
f842b64e
BH		 2745 cmndinfo->status = S_OK;
2746 cmndinfo->info = ha->info;
2747 if (cmndinfo->OpCode != -1) {
1da177e4 2748 TRACE2(("gdth_sync_event(): special cmd 0x%x OK\n",
f842b64e 2749 cmndinfo->OpCode));
1da177e4 2750 /* special commands GDT_CLUST_INFO/GDT_MOUNT ? */
f842b64e 2751 if (cmndinfo->OpCode == GDT_CLUST_INFO) {
1fe6dbf4 2752 ha->hdr[t].cluster_type = (u8)ha->info;
1da177e4
LT		 2753 if (!(ha->hdr[t].cluster_type &
2754 CLUSTER_MOUNTED)) {
2755 /* NOT MOUNTED -> MOUNT */
f842b64e 2756 cmndinfo->OpCode = GDT_MOUNT;
1da177e4
LT		 2757 if (ha->hdr[t].cluster_type &
2758 CLUSTER_RESERVED) {
2759 /* cluster drive RESERVED (on the other node) */
f842b64e 2760 cmndinfo->phase = -2; /* reservation conflict */
1da177e4
LT		 2761 }
2762 } else {
f842b64e 2763 cmndinfo->OpCode = -1;
1da177e4
LT		 2764 }
2765 } else {
f842b64e 2766 if (cmndinfo->OpCode == GDT_MOUNT) {
1da177e4
LT		 2767 ha->hdr[t].cluster_type |= CLUSTER_MOUNTED;
2768 ha->hdr[t].media_changed = TRUE;
f842b64e 2769 } else if (cmndinfo->OpCode == GDT_UNMOUNT) {
1da177e4
LT		 2770 ha->hdr[t].cluster_type &= ~CLUSTER_MOUNTED;
2771 ha->hdr[t].media_changed = TRUE;
2772 }
f842b64e 2773 cmndinfo->OpCode = -1;
1da177e4
LT		 2774 }
2775 /* retry */
f842b64e 2776 cmndinfo->priority = HIGH_PRI;
1da177e4
LT		 2777 return 2;
2778 } else {
2779 /* RESERVE/RELEASE ? */
2780 if (scp->cmnd[0] == RESERVE) {
2781 ha->hdr[t].cluster_type |= CLUSTER_RESERVED;
2782 } else if (scp->cmnd[0] == RELEASE) {
2783 ha->hdr[t].cluster_type &= ~CLUSTER_RESERVED;
2784 }
2785 scp->result = DID_OK << 16;
2786 scp->sense_buffer[0] = 0;
2787 }
2788 } else {
f842b64e
BH		 2789 cmndinfo->status = ha->status;
2790 cmndinfo->info = ha->info;
1da177e4 2791
f842b64e 2792 if (cmndinfo->OpCode != -1) {
1da177e4 2793 TRACE2(("gdth_sync_event(): special cmd 0x%x error 0x%x\n",
f842b64e
BH		 2794 cmndinfo->OpCode, ha->status));
2795 if (cmndinfo->OpCode == GDT_SCAN_START ||
2796 cmndinfo->OpCode == GDT_SCAN_END) {
2797 cmndinfo->OpCode = -1;
1da177e4 2798 /* retry */
f842b64e 2799 cmndinfo->priority = HIGH_PRI;
1da177e4
LT		 2800 return 2;
2801 }
2802 memset((char*)scp->sense_buffer,0,16);
2803 scp->sense_buffer[0] = 0x70;
2804 scp->sense_buffer[2] = NOT_READY;
2805 scp->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
2806 } else if (service == CACHESERVICE) {
2807 if (ha->status == S_CACHE_UNKNOWN &&
2808 (ha->hdr[t].cluster_type &
2809 CLUSTER_RESERVE_STATE) == CLUSTER_RESERVE_STATE) {
2810 /* bus reset -> force GDT_CLUST_INFO */
2811 ha->hdr[t].cluster_type &= ~CLUSTER_RESERVED;
2812 }
2813 memset((char*)scp->sense_buffer,0,16);
1fe6dbf4 2814 if (ha->status == (u16)S_CACHE_RESERV) {
1da177e4
LT		 2815 scp->result = (DID_OK << 16) | (RESERVATION_CONFLICT << 1);
2816 } else {
2817 scp->sense_buffer[0] = 0x70;
2818 scp->sense_buffer[2] = NOT_READY;
2819 scp->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
2820 }
3058d5de 2821 if (!cmndinfo->internal_command) {
1da177e4 2822 ha->dvr.size = sizeof(ha->dvr.eu.sync);
45f1a41b 2823 ha->dvr.eu.sync.ionode = ha->hanum;
1da177e4
LT		 2824 ha->dvr.eu.sync.service = service;
2825 ha->dvr.eu.sync.status = ha->status;
2826 ha->dvr.eu.sync.info = ha->info;
2827 ha->dvr.eu.sync.hostdrive = t;
2828 if (ha->status >= 0x8000)
2829 gdth_store_event(ha, ES_SYNC, 0, &ha->dvr);
2830 else
2831 gdth_store_event(ha, ES_SYNC, service, &ha->dvr);
2832 }
2833 } else {
2834 /* sense buffer filled from controller firmware (DMA) */
2835 if (ha->status != S_RAW_SCSI || ha->info >= 0x100) {
2836 scp->result = DID_BAD_TARGET << 16;
2837 } else {
2838 scp->result = (DID_OK << 16) | ha->info;
2839 }
2840 }
2841 }
f842b64e
BH		 2842 if (!cmndinfo->wait_for_completion)
2843 cmndinfo->wait_for_completion++;
1da177e4
LT		 2844 else
2845 return 1;
2846 }
2847
2848 return 0;
2849}
2850
2851static char *async_cache_tab[] = {
2852/* 0*/ "\011\000\002\002\002\004\002\006\004"
2853 "GDT HA %u, service %u, async. status %u/%lu unknown",
2854/* 1*/ "\011\000\002\002\002\004\002\006\004"
2855 "GDT HA %u, service %u, async. status %u/%lu unknown",
2856/* 2*/ "\005\000\002\006\004"
2857 "GDT HA %u, Host Drive %lu not ready",
2858/* 3*/ "\005\000\002\006\004"
2859 "GDT HA %u, Host Drive %lu: REASSIGN not successful and/or data error on reassigned blocks. Drive may crash in the future and should be replaced",
2860/* 4*/ "\005\000\002\006\004"
2861 "GDT HA %u, mirror update on Host Drive %lu failed",
2862/* 5*/ "\005\000\002\006\004"
2863 "GDT HA %u, Mirror Drive %lu failed",
2864/* 6*/ "\005\000\002\006\004"
2865 "GDT HA %u, Mirror Drive %lu: REASSIGN not successful and/or data error on reassigned blocks. Drive may crash in the future and should be replaced",
2866/* 7*/ "\005\000\002\006\004"
2867 "GDT HA %u, Host Drive %lu write protected",
2868/* 8*/ "\005\000\002\006\004"
2869 "GDT HA %u, media changed in Host Drive %lu",
2870/* 9*/ "\005\000\002\006\004"
2871 "GDT HA %u, Host Drive %lu is offline",
2872/*10*/ "\005\000\002\006\004"
2873 "GDT HA %u, media change of Mirror Drive %lu",
2874/*11*/ "\005\000\002\006\004"
2875 "GDT HA %u, Mirror Drive %lu is write protected",
2876/*12*/ "\005\000\002\006\004"
2877 "GDT HA %u, general error on Host Drive %lu. Please check the devices of this drive!",
2878/*13*/ "\007\000\002\006\002\010\002"
2879 "GDT HA %u, Array Drive %u: Cache Drive %u failed",
2880/*14*/ "\005\000\002\006\002"
2881 "GDT HA %u, Array Drive %u: FAIL state entered",
2882/*15*/ "\005\000\002\006\002"
2883 "GDT HA %u, Array Drive %u: error",
2884/*16*/ "\007\000\002\006\002\010\002"
2885 "GDT HA %u, Array Drive %u: failed drive replaced by Cache Drive %u",
2886/*17*/ "\005\000\002\006\002"
2887 "GDT HA %u, Array Drive %u: parity build failed",
2888/*18*/ "\005\000\002\006\002"
2889 "GDT HA %u, Array Drive %u: drive rebuild failed",
2890/*19*/ "\005\000\002\010\002"
2891 "GDT HA %u, Test of Hot Fix %u failed",
2892/*20*/ "\005\000\002\006\002"
2893 "GDT HA %u, Array Drive %u: drive build finished successfully",
2894/*21*/ "\005\000\002\006\002"
2895 "GDT HA %u, Array Drive %u: drive rebuild finished successfully",
2896/*22*/ "\007\000\002\006\002\010\002"
2897 "GDT HA %u, Array Drive %u: Hot Fix %u activated",
2898/*23*/ "\005\000\002\006\002"
2899 "GDT HA %u, Host Drive %u: processing of i/o aborted due to serious drive error",
2900/*24*/ "\005\000\002\010\002"
2901 "GDT HA %u, mirror update on Cache Drive %u completed",
2902/*25*/ "\005\000\002\010\002"
2903 "GDT HA %u, mirror update on Cache Drive %lu failed",
2904/*26*/ "\005\000\002\006\002"
2905 "GDT HA %u, Array Drive %u: drive rebuild started",
2906/*27*/ "\005\000\002\012\001"
2907 "GDT HA %u, Fault bus %u: SHELF OK detected",
2908/*28*/ "\005\000\002\012\001"
2909 "GDT HA %u, Fault bus %u: SHELF not OK detected",
2910/*29*/ "\007\000\002\012\001\013\001"
2911 "GDT HA %u, Fault bus %u, ID %u: Auto Hot Plug started",
2912/*30*/ "\007\000\002\012\001\013\001"
2913 "GDT HA %u, Fault bus %u, ID %u: new disk detected",
2914/*31*/ "\007\000\002\012\001\013\001"
2915 "GDT HA %u, Fault bus %u, ID %u: old disk detected",
2916/*32*/ "\007\000\002\012\001\013\001"
2917 "GDT HA %u, Fault bus %u, ID %u: plugging an active disk is invalid",
2918/*33*/ "\007\000\002\012\001\013\001"
2919 "GDT HA %u, Fault bus %u, ID %u: invalid device detected",
2920/*34*/ "\011\000\002\012\001\013\001\006\004"
2921 "GDT HA %u, Fault bus %u, ID %u: insufficient disk capacity (%lu MB required)",
2922/*35*/ "\007\000\002\012\001\013\001"
2923 "GDT HA %u, Fault bus %u, ID %u: disk write protected",
2924/*36*/ "\007\000\002\012\001\013\001"
2925 "GDT HA %u, Fault bus %u, ID %u: disk not available",
2926/*37*/ "\007\000\002\012\001\006\004"
2927 "GDT HA %u, Fault bus %u: swap detected (%lu)",
2928/*38*/ "\007\000\002\012\001\013\001"
2929 "GDT HA %u, Fault bus %u, ID %u: Auto Hot Plug finished successfully",
2930/*39*/ "\007\000\002\012\001\013\001"
2931 "GDT HA %u, Fault bus %u, ID %u: Auto Hot Plug aborted due to user Hot Plug",
2932/*40*/ "\007\000\002\012\001\013\001"
2933 "GDT HA %u, Fault bus %u, ID %u: Auto Hot Plug aborted",
2934/*41*/ "\007\000\002\012\001\013\001"
2935 "GDT HA %u, Fault bus %u, ID %u: Auto Hot Plug for Hot Fix started",
2936/*42*/ "\005\000\002\006\002"
2937 "GDT HA %u, Array Drive %u: drive build started",
2938/*43*/ "\003\000\002"
2939 "GDT HA %u, DRAM parity error detected",
2940/*44*/ "\005\000\002\006\002"
2941 "GDT HA %u, Mirror Drive %u: update started",
2942/*45*/ "\007\000\002\006\002\010\002"
2943 "GDT HA %u, Mirror Drive %u: Hot Fix %u activated",
2944/*46*/ "\005\000\002\006\002"
2945 "GDT HA %u, Array Drive %u: no matching Pool Hot Fix Drive available",
2946/*47*/ "\005\000\002\006\002"
2947 "GDT HA %u, Array Drive %u: Pool Hot Fix Drive available",
2948/*48*/ "\005\000\002\006\002"
2949 "GDT HA %u, Mirror Drive %u: no matching Pool Hot Fix Drive available",
2950/*49*/ "\005\000\002\006\002"
2951 "GDT HA %u, Mirror Drive %u: Pool Hot Fix Drive available",
2952/*50*/ "\007\000\002\012\001\013\001"
2953 "GDT HA %u, SCSI bus %u, ID %u: IGNORE_WIDE_RESIDUE message received",
2954/*51*/ "\005\000\002\006\002"
2955 "GDT HA %u, Array Drive %u: expand started",
2956/*52*/ "\005\000\002\006\002"
2957 "GDT HA %u, Array Drive %u: expand finished successfully",
2958/*53*/ "\005\000\002\006\002"
2959 "GDT HA %u, Array Drive %u: expand failed",
2960/*54*/ "\003\000\002"
2961 "GDT HA %u, CPU temperature critical",
2962/*55*/ "\003\000\002"
2963 "GDT HA %u, CPU temperature OK",
2964/*56*/ "\005\000\002\006\004"
2965 "GDT HA %u, Host drive %lu created",
2966/*57*/ "\005\000\002\006\002"
2967 "GDT HA %u, Array Drive %u: expand restarted",
2968/*58*/ "\005\000\002\006\002"
2969 "GDT HA %u, Array Drive %u: expand stopped",
2970/*59*/ "\005\000\002\010\002"
2971 "GDT HA %u, Mirror Drive %u: drive build quited",
2972/*60*/ "\005\000\002\006\002"
2973 "GDT HA %u, Array Drive %u: parity build quited",
2974/*61*/ "\005\000\002\006\002"
2975 "GDT HA %u, Array Drive %u: drive rebuild quited",
2976/*62*/ "\005\000\002\006\002"
2977 "GDT HA %u, Array Drive %u: parity verify started",
2978/*63*/ "\005\000\002\006\002"
2979 "GDT HA %u, Array Drive %u: parity verify done",
2980/*64*/ "\005\000\002\006\002"
2981 "GDT HA %u, Array Drive %u: parity verify failed",
2982/*65*/ "\005\000\002\006\002"
2983 "GDT HA %u, Array Drive %u: parity error detected",
2984/*66*/ "\005\000\002\006\002"
2985 "GDT HA %u, Array Drive %u: parity verify quited",
2986/*67*/ "\005\000\002\006\002"
2987 "GDT HA %u, Host Drive %u reserved",
2988/*68*/ "\005\000\002\006\002"
2989 "GDT HA %u, Host Drive %u mounted and released",
2990/*69*/ "\005\000\002\006\002"
2991 "GDT HA %u, Host Drive %u released",
2992/*70*/ "\003\000\002"
2993 "GDT HA %u, DRAM error detected and corrected with ECC",
2994/*71*/ "\003\000\002"
2995 "GDT HA %u, Uncorrectable DRAM error detected with ECC",
2996/*72*/ "\011\000\002\012\001\013\001\014\001"
2997 "GDT HA %u, SCSI bus %u, ID %u, LUN %u: reassigning block",
2998/*73*/ "\005\000\002\006\002"
2999 "GDT HA %u, Host drive %u resetted locally",
3000/*74*/ "\005\000\002\006\002"
3001 "GDT HA %u, Host drive %u resetted remotely",
3002/*75*/ "\003\000\002"
3003 "GDT HA %u, async. status 75 unknown",
3004};
3005
3006
45f1a41b 3007static int gdth_async_event(gdth_ha_str *ha)
1da177e4 3008{
1da177e4 3009 gdth_cmd_str *cmdp;
1da177e4 3010
1da177e4
LT		 3011 cmdp= ha->pccb;
3012 TRACE2(("gdth_async_event() ha %d serv %d\n",
45f1a41b 3013 ha->hanum, ha->service));
1da177e4
LT		 3014
3015 if (ha->service == SCREENSERVICE) {
3016 if (ha->status == MSG_REQUEST) {
45f1a41b 3017 while (gdth_test_busy(ha))
1da177e4
LT		 3018 gdth_delay(0);
3019 cmdp->Service = SCREENSERVICE;
3020 cmdp->RequestBuffer = SCREEN_CMND;
45f1a41b 3021 gdth_set_sema0(ha);
1da177e4
LT		 3022 cmdp->OpCode = GDT_READ;
3023 cmdp->BoardNode = LOCALBOARD;
3024 cmdp->u.screen.reserved = 0;
3025 cmdp->u.screen.su.msg.msg_handle= MSG_INV_HANDLE;
3026 cmdp->u.screen.su.msg.msg_addr = ha->msg_phys;
3027 ha->cmd_offs_dpmem = 0;
3028 ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr)
1fe6dbf4 3029 + sizeof(u64);
1da177e4 3030 ha->cmd_cnt = 0;
45f1a41b 3031 gdth_copy_command(ha);
31481455 3032 printk("[PCI %d/%d] ",(u16)(ha->brd_phys>>8),
1fe6dbf4 3033 (u16)((ha->brd_phys>>3)&0x1f));
45f1a41b 3034 gdth_release_event(ha);
1da177e4
LT		 3035 }
3036
3037 } else {
3038 if (ha->type == GDT_PCIMPR &&
3039 (ha->fw_vers & 0xff) >= 0x1a) {
3040 ha->dvr.size = 0;
45f1a41b 3041 ha->dvr.eu.async.ionode = ha->hanum;
1da177e4
LT		 3042 ha->dvr.eu.async.status = ha->status;
3043 /* severity and event_string already set! */
3044 } else {
3045 ha->dvr.size = sizeof(ha->dvr.eu.async);
45f1a41b 3046 ha->dvr.eu.async.ionode = ha->hanum;
1da177e4
LT		 3047 ha->dvr.eu.async.service = ha->service;
3048 ha->dvr.eu.async.status = ha->status;
3049 ha->dvr.eu.async.info = ha->info;
1fe6dbf4 3050 *(u32 *)ha->dvr.eu.async.scsi_coord = ha->info2;
1da177e4
LT		 3051 }
3052 gdth_store_event( ha, ES_ASYNC, ha->service, &ha->dvr );
3053 gdth_log_event( &ha->dvr, NULL );
3054
3055 /* new host drive from expand? */
3056 if (ha->service == CACHESERVICE && ha->status == 56) {
3057 TRACE2(("gdth_async_event(): new host drive %d created\n",
1fe6dbf4
DJ		 3058 (u16)ha->info));
3059 /* gdth_analyse_hdrive(hanum, (u16)ha->info); */
1da177e4
LT		 3060 }
3061 }
3062 return 1;
3063}
3064
3065static void gdth_log_event(gdth_evt_data *dvr, char *buffer)
3066{
3067 gdth_stackframe stack;
3068 char *f = NULL;
3069 int i,j;
3070
3071 TRACE2(("gdth_log_event()\n"));
3072 if (dvr->size == 0) {
3073 if (buffer == NULL) {
3074 printk("Adapter %d: %s\n",dvr->eu.async.ionode,dvr->event_string);
3075 } else {
3076 sprintf(buffer,"Adapter %d: %s\n",
3077 dvr->eu.async.ionode,dvr->event_string);
3078 }
3079 } else if (dvr->eu.async.service == CACHESERVICE &&
3080 INDEX_OK(dvr->eu.async.status, async_cache_tab)) {
3081 TRACE2(("GDT: Async. event cache service, event no.: %d\n",
3082 dvr->eu.async.status));
3083
3084 f = async_cache_tab[dvr->eu.async.status];
3085
3086 /* i: parameter to push, j: stack element to fill */
3087 for (j=0,i=1; i < f[0]; i+=2) {
3088 switch (f[i+1]) {
3089 case 4:
1fe6dbf4 3090 stack.b[j++] = *(u32*)&dvr->eu.stream[(int)f[i]];
1da177e4
LT		 3091 break;
3092 case 2:
1fe6dbf4 3093 stack.b[j++] = *(u16*)&dvr->eu.stream[(int)f[i]];
1da177e4
LT		 3094 break;
3095 case 1:
1fe6dbf4 3096 stack.b[j++] = *(u8*)&dvr->eu.stream[(int)f[i]];
1da177e4
LT		 3097 break;
3098 default:
3099 break;
3100 }
3101 }
3102
3103 if (buffer == NULL) {
3104 printk(&f[(int)f[0]],stack);
3105 printk("\n");
3106 } else {
3107 sprintf(buffer,&f[(int)f[0]],stack);
3108 }
3109
3110 } else {
3111 if (buffer == NULL) {
3112 printk("GDT HA %u, Unknown async. event service %d event no. %d\n",
3113 dvr->eu.async.ionode,dvr->eu.async.service,dvr->eu.async.status);
3114 } else {
3115 sprintf(buffer,"GDT HA %u, Unknown async. event service %d event no. %d",
3116 dvr->eu.async.ionode,dvr->eu.async.service,dvr->eu.async.status);
3117 }
3118 }
3119}
3120
3121#ifdef GDTH_STATISTICS
1fe6dbf4 3122static u8 gdth_timer_running;
2d6f0d0c 3123
7932589f 3124static void gdth_timeout(struct timer_list *unused)
1da177e4 3125{
1fe6dbf4 3126 u32 i;
91ebc1fa 3127 struct scsi_cmnd *nscp;
1da177e4 3128 gdth_ha_str *ha;
1fe6dbf4 3129 unsigned long flags;
1da177e4 3130
2d6f0d0c
JB		 3131 if(unlikely(list_empty(&gdth_instances))) {
3132 gdth_timer_running = 0;
3133 return;
3134 }
b31ddd31 3135
884f7fba 3136 ha = list_first_entry(&gdth_instances, gdth_ha_str, list);
1da177e4
LT		 3137 spin_lock_irqsave(&ha->smp_lock, flags);
3138
3139 for (act_stats=0,i=0; i<GDTH_MAXCMDS; ++i)
3140 if (ha->cmd_tab[i].cmnd != UNUSED_CMND)
3141 ++act_stats;
3142
91ebc1fa
JT		 3143 for (act_rq=0,
3144 nscp=ha->req_first; nscp; nscp=(struct scsi_cmnd*)nscp->SCp.ptr)
1da177e4
LT		 3145 ++act_rq;
3146
3147 TRACE2(("gdth_to(): ints %d, ios %d, act_stats %d, act_rq %d\n",
3148 act_ints, act_ios, act_stats, act_rq));
3149 act_ints = act_ios = 0;
3150
3151 gdth_timer.expires = jiffies + 30 * HZ;
3152 add_timer(&gdth_timer);
3153 spin_unlock_irqrestore(&ha->smp_lock, flags);
3154}
2d6f0d0c
JB		 3155
3156static void gdth_timer_init(void)
3157{
3158 if (gdth_timer_running)
3159 return;
3160 gdth_timer_running = 1;
3161 TRACE2(("gdth_detect(): Initializing timer !\n"));
3162 gdth_timer.expires = jiffies + HZ;
2d6f0d0c
JB		 3163 add_timer(&gdth_timer);
3164}
3165#else
3166static inline void gdth_timer_init(void)
3167{
3168}
1da177e4
LT		 3169#endif
3170
1da177e4 3171
45f1a41b 3172static const char *gdth_ctr_name(gdth_ha_str *ha)
1da177e4 3173{
1da177e4
LT		 3174 TRACE2(("gdth_ctr_name()\n"));
3175
31481455 3176 if (ha->type == GDT_PCI) {
8e9a8a0d 3177 switch (ha->pdev->device) {
1da177e4
LT		 3178 case PCI_DEVICE_ID_VORTEX_GDT60x0:
3179 return("GDT6000/6020/6050");
3180 case PCI_DEVICE_ID_VORTEX_GDT6000B:
3181 return("GDT6000B/6010");
3182 }
3183 }
3184 /* new controllers (GDT_PCINEW, GDT_PCIMPR, ..) use board_info IOCTL! */
3185
3186 return("");
3187}
3188
8e879041 3189static const char *gdth_info(struct Scsi_Host *shp)
1da177e4 3190{
45f1a41b 3191 gdth_ha_str *ha = shost_priv(shp);
1da177e4
LT		 3192
3193 TRACE2(("gdth_info()\n"));
1da177e4
LT		 3194 return ((const char *)ha->binfo.type_string);
3195}
3196
242f9dcb
JA		 3197static enum blk_eh_timer_return gdth_timed_out(struct scsi_cmnd *scp)
3198{
3199 gdth_ha_str *ha = shost_priv(scp->device->host);
3200 struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
1fe6dbf4
DJ		 3201 u8 b, t;
3202 unsigned long flags;
6600593c 3203 enum blk_eh_timer_return retval = BLK_EH_DONE;
242f9dcb
JA		 3204
3205 TRACE(("%s() cmd 0x%x\n", scp->cmnd[0], __func__));
3206 b = scp->device->channel;
3207 t = scp->device->id;
3208
3209 /*
3210 * We don't really honor the command timeout, but we try to
3211 * honor 6 times of the actual command timeout! So reset the
3212 * timer if this is less than 6th timeout on this command!
3213 */
3214 if (++cmndinfo->timeout_count < 6)
3215 retval = BLK_EH_RESET_TIMER;
3216
3217 /* Reset the timeout if it is locked IO */
3218 spin_lock_irqsave(&ha->smp_lock, flags);
3219 if ((b != ha->virt_bus && ha->raw[BUS_L2P(ha, b)].lock) ||
3220 (b == ha->virt_bus && t < MAX_HDRIVES && ha->hdr[t].lock)) {
3221 TRACE2(("%s(): locked IO, reset timeout\n", __func__));
3222 retval = BLK_EH_RESET_TIMER;
3223 }
3224 spin_unlock_irqrestore(&ha->smp_lock, flags);
3225
3226 return retval;
3227}
3228
3229
91ebc1fa 3230static int gdth_eh_bus_reset(struct scsi_cmnd *scp)
1da177e4 3231{
45f1a41b
BH		 3232 gdth_ha_str *ha = shost_priv(scp->device->host);
3233 int i;
1fe6dbf4 3234 unsigned long flags;
91ebc1fa 3235 struct scsi_cmnd *cmnd;
1fe6dbf4 3236 u8 b;
1da177e4
LT		 3237
3238 TRACE2(("gdth_eh_bus_reset()\n"));
3239
52759e6a 3240 b = scp->device->channel;
1da177e4
LT		 3241
3242 /* clear command tab */
3243 spin_lock_irqsave(&ha->smp_lock, flags);
3244 for (i = 0; i < GDTH_MAXCMDS; ++i) {
3245 cmnd = ha->cmd_tab[i].cmnd;
3246 if (!SPECIAL_SCP(cmnd) && cmnd->device->channel == b)
3247 ha->cmd_tab[i].cmnd = UNUSED_CMND;
3248 }
3249 spin_unlock_irqrestore(&ha->smp_lock, flags);
3250
3251 if (b == ha->virt_bus) {
3252 /* host drives */
3253 for (i = 0; i < MAX_HDRIVES; ++i) {
3254 if (ha->hdr[i].present) {
3255 spin_lock_irqsave(&ha->smp_lock, flags);
3256 gdth_polling = TRUE;
45f1a41b 3257 while (gdth_test_busy(ha))
1da177e4 3258 gdth_delay(0);
45f1a41b 3259 if (gdth_internal_cmd(ha, CACHESERVICE,
1da177e4
LT		 3260 GDT_CLUST_RESET, i, 0, 0))
3261 ha->hdr[i].cluster_type &= ~CLUSTER_RESERVED;
3262 gdth_polling = FALSE;
3263 spin_unlock_irqrestore(&ha->smp_lock, flags);
3264 }
3265 }
3266 } else {
3267 /* raw devices */
3268 spin_lock_irqsave(&ha->smp_lock, flags);
3269 for (i = 0; i < MAXID; ++i)
3270 ha->raw[BUS_L2P(ha,b)].io_cnt[i] = 0;
3271 gdth_polling = TRUE;
45f1a41b 3272 while (gdth_test_busy(ha))
1da177e4 3273 gdth_delay(0);
45f1a41b 3274 gdth_internal_cmd(ha, SCSIRAWSERVICE, GDT_RESET_BUS,
1da177e4
LT		 3275 BUS_L2P(ha,b), 0, 0);
3276 gdth_polling = FALSE;
cbd5f69b 3277 spin_unlock_irqrestore(&ha->smp_lock, flags);
1da177e4
LT		 3278 }
3279 return SUCCESS;
3280}
3281
8e879041 3282static int gdth_bios_param(struct scsi_device *sdev,struct block_device *bdev,sector_t cap,int *ip)
1da177e4 3283{
1fe6dbf4 3284 u8 b, t;
45f1a41b 3285 gdth_ha_str *ha = shost_priv(sdev->host);
1da177e4
LT		 3286 struct scsi_device *sd;
3287 unsigned capacity;
3288
1da177e4
LT		 3289 sd = sdev;
3290 capacity = cap;
52759e6a 3291 b = sd->channel;
1da177e4 3292 t = sd->id;
45f1a41b 3293 TRACE2(("gdth_bios_param() ha %d bus %d target %d\n", ha->hanum, b, t));
1da177e4
LT		 3294
3295 if (b != ha->virt_bus || ha->hdr[t].heads == 0) {
3296 /* raw device or host drive without mapping information */
3297 TRACE2(("Evaluate mapping\n"));
3298 gdth_eval_mapping(capacity,&ip[2],&ip[0],&ip[1]);
3299 } else {
3300 ip[0] = ha->hdr[t].heads;
3301 ip[1] = ha->hdr[t].secs;
3302 ip[2] = capacity / ip[0] / ip[1];
3303 }
3304
3305 TRACE2(("gdth_bios_param(): %d heads, %d secs, %d cyls\n",
3306 ip[0],ip[1],ip[2]));
3307 return 0;
3308}
3309
3310
f281233d 3311static int gdth_queuecommand_lck(struct scsi_cmnd *scp,
b8bff2ae 3312 void (*done)(struct scsi_cmnd *))
1da177e4 3313{
45f1a41b 3314 gdth_ha_str *ha = shost_priv(scp->device->host);
3058d5de 3315 struct gdth_cmndinfo *cmndinfo;
1da177e4
LT		 3316
3317 TRACE(("gdth_queuecommand() cmd 0x%x\n", scp->cmnd[0]));
3058d5de
BH		 3318
3319 cmndinfo = gdth_get_cmndinfo(ha);
3320 BUG_ON(!cmndinfo);
3321
b8bff2ae 3322 scp->scsi_done = done;
242f9dcb 3323 cmndinfo->timeout_count = 0;
f842b64e 3324 cmndinfo->priority = DEFAULT_PRI;
3892d88a 3325
3058d5de
BH		 3326 return __gdth_queuecommand(ha, scp, cmndinfo);
3327}
3328
f281233d
JG		 3329static DEF_SCSI_QCMD(gdth_queuecommand)
3330
3058d5de
BH		 3331static int __gdth_queuecommand(gdth_ha_str *ha, struct scsi_cmnd *scp,
3332 struct gdth_cmndinfo *cmndinfo)
3333{
3334 scp->host_scribble = (unsigned char *)cmndinfo;
f842b64e
BH		 3335 cmndinfo->wait_for_completion = 1;
3336 cmndinfo->phase = -1;
3337 cmndinfo->OpCode = -1;
1da177e4 3338
1da177e4
LT		 3339#ifdef GDTH_STATISTICS
3340 ++act_ios;
3341#endif
3342
f842b64e 3343 gdth_putq(ha, scp, cmndinfo->priority);
45f1a41b 3344 gdth_next(ha);
1da177e4
LT		 3345 return 0;
3346}
3347
3348
3349static int gdth_open(struct inode *inode, struct file *filep)
3350{
3351 gdth_ha_str *ha;
1da177e4 3352
c45d15d2 3353 mutex_lock(&gdth_mutex);
884f7fba 3354 list_for_each_entry(ha, &gdth_instances, list) {
1da177e4 3355 if (!ha->sdev)
884f7fba 3356 ha->sdev = scsi_get_host_dev(ha->shost);
1da177e4 3357 }
c45d15d2 3358 mutex_unlock(&gdth_mutex);
1da177e4
LT		 3359
3360 TRACE(("gdth_open()\n"));
3361 return 0;
3362}
3363
3364static int gdth_close(struct inode *inode, struct file *filep)
3365{
3366 TRACE(("gdth_close()\n"));
3367 return 0;
3368}
3369
3370static int ioc_event(void __user *arg)
3371{
3372 gdth_ioctl_event evt;
3373 gdth_ha_str *ha;
1fe6dbf4 3374 unsigned long flags;
1da177e4 3375
884f7fba
BH		 3376 if (copy_from_user(&evt, arg, sizeof(gdth_ioctl_event)))
3377 return -EFAULT;
3378 ha = gdth_find_ha(evt.ionode);
3379 if (!ha)
1da177e4 3380 return -EFAULT;
1da177e4
LT		 3381
3382 if (evt.erase == 0xff) {
3383 if (evt.event.event_source == ES_TEST)
3384 evt.event.event_data.size=sizeof(evt.event.event_data.eu.test);
3385 else if (evt.event.event_source == ES_DRIVER)
3386 evt.event.event_data.size=sizeof(evt.event.event_data.eu.driver);
3387 else if (evt.event.event_source == ES_SYNC)
3388 evt.event.event_data.size=sizeof(evt.event.event_data.eu.sync);
3389 else
3390 evt.event.event_data.size=sizeof(evt.event.event_data.eu.async);
3391 spin_lock_irqsave(&ha->smp_lock, flags);
3392 gdth_store_event(ha, evt.event.event_source, evt.event.event_idx,
3393 &evt.event.event_data);
3394 spin_unlock_irqrestore(&ha->smp_lock, flags);
3395 } else if (evt.erase == 0xfe) {
3396 gdth_clear_events();
3397 } else if (evt.erase == 0) {
3398 evt.handle = gdth_read_event(ha, evt.handle, &evt.event);
3399 } else {
3400 gdth_readapp_event(ha, evt.erase, &evt.event);
3401 }
3402 if (copy_to_user(arg, &evt, sizeof(gdth_ioctl_event)))
3403 return -EFAULT;
3404 return 0;
3405}
3406
3407static int ioc_lockdrv(void __user *arg)
3408{
3409 gdth_ioctl_lockdrv ldrv;
1fe6dbf4
DJ		 3410 u8 i, j;
3411 unsigned long flags;
1da177e4
LT		 3412 gdth_ha_str *ha;
3413
884f7fba 3414 if (copy_from_user(&ldrv, arg, sizeof(gdth_ioctl_lockdrv)))
1da177e4 3415 return -EFAULT;
884f7fba
BH		 3416 ha = gdth_find_ha(ldrv.ionode);
3417 if (!ha)
3418 return -EFAULT;
3419
1da177e4
LT		 3420 for (i = 0; i < ldrv.drive_cnt && i < MAX_HDRIVES; ++i) {
3421 j = ldrv.drives[i];
3422 if (j >= MAX_HDRIVES || !ha->hdr[j].present)
3423 continue;
3424 if (ldrv.lock) {
3425 spin_lock_irqsave(&ha->smp_lock, flags);
3426 ha->hdr[j].lock = 1;
3427 spin_unlock_irqrestore(&ha->smp_lock, flags);
45f1a41b 3428 gdth_wait_completion(ha, ha->bus_cnt, j);
1da177e4
LT		 3429 } else {
3430 spin_lock_irqsave(&ha->smp_lock, flags);
3431 ha->hdr[j].lock = 0;
3432 spin_unlock_irqrestore(&ha->smp_lock, flags);
45f1a41b 3433 gdth_next(ha);
1da177e4
LT		 3434 }
3435 }
3436 return 0;
3437}
3438
3439static int ioc_resetdrv(void __user *arg, char *cmnd)
3440{
3441 gdth_ioctl_reset res;
3442 gdth_cmd_str cmd;
1da177e4 3443 gdth_ha_str *ha;
cbd5f69b 3444 int rval;
1da177e4
LT		 3445
3446 if (copy_from_user(&res, arg, sizeof(gdth_ioctl_reset)) ||
884f7fba
BH		 3447 res.number >= MAX_HDRIVES)
3448 return -EFAULT;
3449 ha = gdth_find_ha(res.ionode);
3450 if (!ha)
1da177e4 3451 return -EFAULT;
45f1a41b 3452
1da177e4
LT		 3453 if (!ha->hdr[res.number].present)
3454 return 0;
3455 memset(&cmd, 0, sizeof(gdth_cmd_str));
3456 cmd.Service = CACHESERVICE;
3457 cmd.OpCode = GDT_CLUST_RESET;
3458 if (ha->cache_feat & GDT_64BIT)
3459 cmd.u.cache64.DeviceNo = res.number;
3460 else
3461 cmd.u.cache.DeviceNo = res.number;
cbd5f69b
LA		 3462
3463 rval = __gdth_execute(ha->sdev, &cmd, cmnd, 30, NULL);
3464 if (rval < 0)
3465 return rval;
3466 res.status = rval;
1da177e4
LT		 3467
3468 if (copy_to_user(arg, &res, sizeof(gdth_ioctl_reset)))
3469 return -EFAULT;
3470 return 0;
3471}
3472
9f475ebf
CH		 3473static void gdth_ioc_cacheservice(gdth_ha_str *ha, gdth_ioctl_general *gen,
3474 u64 paddr)
1da177e4 3475{
9f475ebf
CH		 3476 if (ha->cache_feat & GDT_64BIT) {
3477 /* copy elements from 32-bit IOCTL structure */
3478 gen->command.u.cache64.BlockCnt = gen->command.u.cache.BlockCnt;
3479 gen->command.u.cache64.BlockNo = gen->command.u.cache.BlockNo;
3480 gen->command.u.cache64.DeviceNo = gen->command.u.cache.DeviceNo;
3481
3482 if (ha->cache_feat & SCATTER_GATHER) {
3483 gen->command.u.cache64.DestAddr = (u64)-1;
3484 gen->command.u.cache64.sg_canz = 1;
3485 gen->command.u.cache64.sg_lst[0].sg_ptr = paddr;
3486 gen->command.u.cache64.sg_lst[0].sg_len = gen->data_len;
3487 gen->command.u.cache64.sg_lst[1].sg_len = 0;
3488 } else {
3489 gen->command.u.cache64.DestAddr = paddr;
3490 gen->command.u.cache64.sg_canz = 0;
3491 }
3492 } else {
3493 if (ha->cache_feat & SCATTER_GATHER) {
3494 gen->command.u.cache.DestAddr = 0xffffffff;
3495 gen->command.u.cache.sg_canz = 1;
3496 gen->command.u.cache.sg_lst[0].sg_ptr = (u32)paddr;
3497 gen->command.u.cache.sg_lst[0].sg_len = gen->data_len;
3498 gen->command.u.cache.sg_lst[1].sg_len = 0;
3499 } else {
3500 gen->command.u.cache.DestAddr = paddr;
3501 gen->command.u.cache.sg_canz = 0;
3502 }
3503 }
3504}
1da177e4 3505
9f475ebf
CH		 3506static void gdth_ioc_scsiraw(gdth_ha_str *ha, gdth_ioctl_general *gen,
3507 u64 paddr)
3508{
3509 if (ha->raw_feat & GDT_64BIT) {
3510 /* copy elements from 32-bit IOCTL structure */
3511 char cmd[16];
3512
3513 gen->command.u.raw64.sense_len = gen->command.u.raw.sense_len;
3514 gen->command.u.raw64.bus = gen->command.u.raw.bus;
3515 gen->command.u.raw64.lun = gen->command.u.raw.lun;
3516 gen->command.u.raw64.target = gen->command.u.raw.target;
3517 memcpy(cmd, gen->command.u.raw.cmd, 16);
3518 memcpy(gen->command.u.raw64.cmd, cmd, 16);
3519 gen->command.u.raw64.clen = gen->command.u.raw.clen;
3520 gen->command.u.raw64.sdlen = gen->command.u.raw.sdlen;
3521 gen->command.u.raw64.direction = gen->command.u.raw.direction;
3522
3523 /* addresses */
3524 if (ha->raw_feat & SCATTER_GATHER) {
3525 gen->command.u.raw64.sdata = (u64)-1;
3526 gen->command.u.raw64.sg_ranz = 1;
3527 gen->command.u.raw64.sg_lst[0].sg_ptr = paddr;
3528 gen->command.u.raw64.sg_lst[0].sg_len = gen->data_len;
3529 gen->command.u.raw64.sg_lst[1].sg_len = 0;
3530 } else {
3531 gen->command.u.raw64.sdata = paddr;
3532 gen->command.u.raw64.sg_ranz = 0;
1da177e4 3533 }
9f475ebf
CH		 3534
3535 gen->command.u.raw64.sense_data = paddr + gen->data_len;
3536 } else {
3537 if (ha->raw_feat & SCATTER_GATHER) {
3538 gen->command.u.raw.sdata = 0xffffffff;
3539 gen->command.u.raw.sg_ranz = 1;
3540 gen->command.u.raw.sg_lst[0].sg_ptr = (u32)paddr;
3541 gen->command.u.raw.sg_lst[0].sg_len = gen->data_len;
3542 gen->command.u.raw.sg_lst[1].sg_len = 0;
3543 } else {
3544 gen->command.u.raw.sdata = paddr;
3545 gen->command.u.raw.sg_ranz = 0;
1da177e4 3546 }
1da177e4 3547
9f475ebf
CH		 3548 gen->command.u.raw.sense_data = (u32)paddr + gen->data_len;
3549 }
3550}
1da177e4 3551
9f475ebf
CH		 3552static int ioc_general(void __user *arg, char *cmnd)
3553{
3554 gdth_ioctl_general gen;
3555 gdth_ha_str *ha;
3556 char *buf = NULL;
463563fa 3557 dma_addr_t paddr;
9f475ebf
CH		 3558 int rval;
3559
3560 if (copy_from_user(&gen, arg, sizeof(gdth_ioctl_general)))
3561 return -EFAULT;
3562 ha = gdth_find_ha(gen.ionode);
3563 if (!ha)
3564 return -EFAULT;
3565
3566 if (gen.data_len > INT_MAX)
3567 return -EINVAL;
3568 if (gen.sense_len > INT_MAX)
3569 return -EINVAL;
3570 if (gen.data_len + gen.sense_len > INT_MAX)
3571 return -EINVAL;
3572
3573 if (gen.data_len + gen.sense_len > 0) {
bb327df8
CH		 3574 buf = dma_alloc_coherent(&ha->pdev->dev,
3575 gen.data_len + gen.sense_len, &paddr,
3576 GFP_KERNEL);
9f475ebf
CH		 3577 if (!buf)
3578 return -EFAULT;
3579
3580 rval = -EFAULT;
3581 if (copy_from_user(buf, arg + sizeof(gdth_ioctl_general),
3582 gen.data_len + gen.sense_len))
3583 goto out_free_buf;
3584
3585 if (gen.command.OpCode == GDT_IOCTL)
3586 gen.command.u.ioctl.p_param = paddr;
3587 else if (gen.command.Service == CACHESERVICE)
3588 gdth_ioc_cacheservice(ha, &gen, paddr);
3589 else if (gen.command.Service == SCSIRAWSERVICE)
3590 gdth_ioc_scsiraw(ha, &gen, paddr);
3591 else
3592 goto out_free_buf;
3593 }
3594
3595 rval = __gdth_execute(ha->sdev, &gen.command, cmnd, gen.timeout,
3596 &gen.info);
3597 if (rval < 0)
3598 goto out_free_buf;
3599 gen.status = rval;
3600
3601 rval = -EFAULT;
3602 if (copy_to_user(arg + sizeof(gdth_ioctl_general), buf,
3603 gen.data_len + gen.sense_len))
3604 goto out_free_buf;
3605 if (copy_to_user(arg, &gen,
3606 sizeof(gdth_ioctl_general) - sizeof(gdth_cmd_str)))
3607 goto out_free_buf;
3608
3609 rval = 0;
3610out_free_buf:
3e14592d
NC		 3611 if (buf)
3612 dma_free_coherent(&ha->pdev->dev, gen.data_len + gen.sense_len,
3613 buf, paddr);
9f475ebf 3614 return rval;
1da177e4
LT		 3615}
3616
3617static int ioc_hdrlist(void __user *arg, char *cmnd)
3618{
3619 gdth_ioctl_rescan *rsc;
3620 gdth_cmd_str *cmd;
3621 gdth_ha_str *ha;
1fe6dbf4 3622 u8 i;
45f1a41b 3623 int rc = -ENOMEM;
cbd5f69b
LA		 3624 u32 cluster_type = 0;
3625
1da177e4
LT		 3626 rsc = kmalloc(sizeof(*rsc), GFP_KERNEL);
3627 cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
3628 if (!rsc || !cmd)
cbd5f69b 3629 goto free_fail;
1da177e4
LT		 3630
3631 if (copy_from_user(rsc, arg, sizeof(gdth_ioctl_rescan)) ||
884f7fba 3632 (NULL == (ha = gdth_find_ha(rsc->ionode)))) {
1da177e4 3633 rc = -EFAULT;
cbd5f69b 3634 goto free_fail;
1da177e4 3635 }
1da177e4
LT		 3636 memset(cmd, 0, sizeof(gdth_cmd_str));
3637
1da177e4
LT		 3638 for (i = 0; i < MAX_HDRIVES; ++i) {
3639 if (!ha->hdr[i].present) {
3640 rsc->hdr_list[i].bus = 0xff;
3641 continue;
3642 }
3643 rsc->hdr_list[i].bus = ha->virt_bus;
3644 rsc->hdr_list[i].target = i;
3645 rsc->hdr_list[i].lun = 0;
3646 rsc->hdr_list[i].cluster_type = ha->hdr[i].cluster_type;
3647 if (ha->hdr[i].cluster_type & CLUSTER_DRIVE) {
3648 cmd->Service = CACHESERVICE;
3649 cmd->OpCode = GDT_CLUST_INFO;
3650 if (ha->cache_feat & GDT_64BIT)
3651 cmd->u.cache64.DeviceNo = i;
3652 else
3653 cmd->u.cache.DeviceNo = i;
cbd5f69b
LA		 3654 if (__gdth_execute(ha->sdev, cmd, cmnd, 30, &cluster_type) == S_OK)
3655 rsc->hdr_list[i].cluster_type = cluster_type;
1da177e4
LT		 3656 }
3657 }
cbd5f69b 3658
1da177e4
LT		 3659 if (copy_to_user(arg, rsc, sizeof(gdth_ioctl_rescan)))
3660 rc = -EFAULT;
3661 else
cbd5f69b 3662 rc = 0;
1da177e4
LT		 3663
3664free_fail:
3665 kfree(rsc);
3666 kfree(cmd);
3667 return rc;
3668}
3669
3670static int ioc_rescan(void __user *arg, char *cmnd)
3671{
3672 gdth_ioctl_rescan *rsc;
3673 gdth_cmd_str *cmd;
1fe6dbf4
DJ		 3674 u16 i, status, hdr_cnt;
3675 u32 info;
45f1a41b 3676 int cyls, hds, secs;
1da177e4 3677 int rc = -ENOMEM;
1fe6dbf4 3678 unsigned long flags;
1da177e4 3679 gdth_ha_str *ha;
1da177e4
LT		 3680
3681 rsc = kmalloc(sizeof(*rsc), GFP_KERNEL);
3682 cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
3683 if (!cmd || !rsc)
cbd5f69b 3684 goto free_fail;
1da177e4
LT		 3685
3686 if (copy_from_user(rsc, arg, sizeof(gdth_ioctl_rescan)) ||
884f7fba 3687 (NULL == (ha = gdth_find_ha(rsc->ionode)))) {
cbd5f69b
LA		 3688 rc = -EFAULT;
3689 goto free_fail;
1da177e4 3690 }
1da177e4
LT		 3691 memset(cmd, 0, sizeof(gdth_cmd_str));
3692
1da177e4
LT		 3693 if (rsc->flag == 0) {
3694 /* old method: re-init. cache service */
3695 cmd->Service = CACHESERVICE;
3696 if (ha->cache_feat & GDT_64BIT) {
3697 cmd->OpCode = GDT_X_INIT_HOST;
3698 cmd->u.cache64.DeviceNo = LINUX_OS;
3699 } else {
3700 cmd->OpCode = GDT_INIT;
3701 cmd->u.cache.DeviceNo = LINUX_OS;
3702 }
cbd5f69b
LA		 3703
3704 status = __gdth_execute(ha->sdev, cmd, cmnd, 30, &info);
1da177e4 3705 i = 0;
1fe6dbf4 3706 hdr_cnt = (status == S_OK ? (u16)info : 0);
1da177e4
LT		 3707 } else {
3708 i = rsc->hdr_no;
3709 hdr_cnt = i + 1;
3710 }
3711
3712 for (; i < hdr_cnt && i < MAX_HDRIVES; ++i) {
3713 cmd->Service = CACHESERVICE;
3714 cmd->OpCode = GDT_INFO;
3715 if (ha->cache_feat & GDT_64BIT)
3716 cmd->u.cache64.DeviceNo = i;
3717 else
3718 cmd->u.cache.DeviceNo = i;
cbd5f69b
LA		 3719
3720 status = __gdth_execute(ha->sdev, cmd, cmnd, 30, &info);
3721
1da177e4
LT		 3722 spin_lock_irqsave(&ha->smp_lock, flags);
3723 rsc->hdr_list[i].bus = ha->virt_bus;
3724 rsc->hdr_list[i].target = i;
3725 rsc->hdr_list[i].lun = 0;
3726 if (status != S_OK) {
3727 ha->hdr[i].present = FALSE;
3728 } else {
3729 ha->hdr[i].present = TRUE;
3730 ha->hdr[i].size = info;
3731 /* evaluate mapping */
3732 ha->hdr[i].size &= ~SECS32;
3733 gdth_eval_mapping(ha->hdr[i].size,&cyls,&hds,&secs);
3734 ha->hdr[i].heads = hds;
3735 ha->hdr[i].secs = secs;
3736 /* round size */
3737 ha->hdr[i].size = cyls * hds * secs;
3738 }
3739 spin_unlock_irqrestore(&ha->smp_lock, flags);
3740 if (status != S_OK)
3741 continue;
3742
3743 /* extended info, if GDT_64BIT, for drives > 2 TB */
3744 /* but we need ha->info2, not yet stored in scp->SCp */
3745
3746 /* devtype, cluster info, R/W attribs */
3747 cmd->Service = CACHESERVICE;
3748 cmd->OpCode = GDT_DEVTYPE;
3749 if (ha->cache_feat & GDT_64BIT)
3750 cmd->u.cache64.DeviceNo = i;
3751 else
3752 cmd->u.cache.DeviceNo = i;
cbd5f69b
LA		 3753
3754 status = __gdth_execute(ha->sdev, cmd, cmnd, 30, &info);
3755
1da177e4 3756 spin_lock_irqsave(&ha->smp_lock, flags);
1fe6dbf4 3757 ha->hdr[i].devtype = (status == S_OK ? (u16)info : 0);
1da177e4
LT		 3758 spin_unlock_irqrestore(&ha->smp_lock, flags);
3759
3760 cmd->Service = CACHESERVICE;
3761 cmd->OpCode = GDT_CLUST_INFO;
3762 if (ha->cache_feat & GDT_64BIT)
3763 cmd->u.cache64.DeviceNo = i;
3764 else
3765 cmd->u.cache.DeviceNo = i;
cbd5f69b
LA		 3766
3767 status = __gdth_execute(ha->sdev, cmd, cmnd, 30, &info);
3768
1da177e4
LT		 3769 spin_lock_irqsave(&ha->smp_lock, flags);
3770 ha->hdr[i].cluster_type =
1fe6dbf4 3771 ((status == S_OK && !shared_access) ? (u16)info : 0);
1da177e4
LT		 3772 spin_unlock_irqrestore(&ha->smp_lock, flags);
3773 rsc->hdr_list[i].cluster_type = ha->hdr[i].cluster_type;
3774
3775 cmd->Service = CACHESERVICE;
3776 cmd->OpCode = GDT_RW_ATTRIBS;
3777 if (ha->cache_feat & GDT_64BIT)
3778 cmd->u.cache64.DeviceNo = i;
3779 else
3780 cmd->u.cache.DeviceNo = i;
cbd5f69b
LA		 3781
3782 status = __gdth_execute(ha->sdev, cmd, cmnd, 30, &info);
3783
1da177e4 3784 spin_lock_irqsave(&ha->smp_lock, flags);
1fe6dbf4 3785 ha->hdr[i].rw_attribs = (status == S_OK ? (u16)info : 0);
1da177e4
LT		 3786 spin_unlock_irqrestore(&ha->smp_lock, flags);
3787 }
1da177e4
LT		 3788
3789 if (copy_to_user(arg, rsc, sizeof(gdth_ioctl_rescan)))
3790 rc = -EFAULT;
3791 else
cbd5f69b 3792 rc = 0;
1da177e4
LT		 3793
3794free_fail:
3795 kfree(rsc);
3796 kfree(cmd);
3797 return rc;
3798}
3799
f4927c45 3800static int gdth_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
1da177e4
LT		 3801{
3802 gdth_ha_str *ha;
91ebc1fa 3803 struct scsi_cmnd *scp;
1fe6dbf4 3804 unsigned long flags;
1da177e4
LT		 3805 char cmnd[MAX_COMMAND_SIZE];
3806 void __user *argp = (void __user *)arg;
3807
3808 memset(cmnd, 0xff, 12);
3809
3810 TRACE(("gdth_ioctl() cmd 0x%x\n", cmd));
3811
3812 switch (cmd) {
3813 case GDTIOCTL_CTRCNT:
3814 {
3815 int cnt = gdth_ctr_count;
3816 if (put_user(cnt, (int __user *)argp))
3817 return -EFAULT;
3818 break;
3819 }
3820
3821 case GDTIOCTL_DRVERS:
3822 {
3823 int ver = (GDTH_VERSION<<8) | GDTH_SUBVERSION;
3824 if (put_user(ver, (int __user *)argp))
3825 return -EFAULT;
3826 break;
3827 }
3828
3829 case GDTIOCTL_OSVERS:
3830 {
3831 gdth_ioctl_osvers osv;
3832
1fe6dbf4
DJ		 3833 osv.version = (u8)(LINUX_VERSION_CODE >> 16);
3834 osv.subversion = (u8)(LINUX_VERSION_CODE >> 8);
3835 osv.revision = (u16)(LINUX_VERSION_CODE & 0xff);
1da177e4
LT		 3836 if (copy_to_user(argp, &osv, sizeof(gdth_ioctl_osvers)))
3837 return -EFAULT;
3838 break;
3839 }
3840
3841 case GDTIOCTL_CTRTYPE:
3842 {
3843 gdth_ioctl_ctrtype ctrt;
3844
3845 if (copy_from_user(&ctrt, argp, sizeof(gdth_ioctl_ctrtype)) ||
884f7fba 3846 (NULL == (ha = gdth_find_ha(ctrt.ionode))))
1da177e4 3847 return -EFAULT;
884f7fba 3848
31481455
CH		 3849 if (ha->type != GDT_PCIMPR) {
3850 ctrt.type = (u8)((ha->stype<<4) + 6);
1da177e4 3851 } else {
31481455
CH		 3852 ctrt.type = (ha->oem_id == OEM_ID_INTEL ? 0xfd : 0xfe);
3853 if (ha->stype >= 0x300)
3854 ctrt.ext_type = 0x6000 | ha->pdev->subsystem_device;
3855 else
3856 ctrt.ext_type = 0x6000 | ha->stype;
1da177e4 3857 }
31481455
CH		 3858 ctrt.device_id = ha->pdev->device;
3859 ctrt.sub_device_id = ha->pdev->subsystem_device;
1da177e4
LT		 3860 ctrt.info = ha->brd_phys;
3861 ctrt.oem_id = ha->oem_id;
3862 if (copy_to_user(argp, &ctrt, sizeof(gdth_ioctl_ctrtype)))
3863 return -EFAULT;
3864 break;
3865 }
3866
3867 case GDTIOCTL_GENERAL:
3868 return ioc_general(argp, cmnd);
3869
3870 case GDTIOCTL_EVENT:
3871 return ioc_event(argp);
3872
3873 case GDTIOCTL_LOCKDRV:
3874 return ioc_lockdrv(argp);
3875
3876 case GDTIOCTL_LOCKCHN:
3877 {
3878 gdth_ioctl_lockchn lchn;
1fe6dbf4 3879 u8 i, j;
1da177e4
LT		 3880
3881 if (copy_from_user(&lchn, argp, sizeof(gdth_ioctl_lockchn)) ||
884f7fba 3882 (NULL == (ha = gdth_find_ha(lchn.ionode))))
1da177e4 3883 return -EFAULT;
884f7fba 3884
1da177e4
LT		 3885 i = lchn.channel;
3886 if (i < ha->bus_cnt) {
3887 if (lchn.lock) {
3888 spin_lock_irqsave(&ha->smp_lock, flags);
3889 ha->raw[i].lock = 1;
3890 spin_unlock_irqrestore(&ha->smp_lock, flags);
242f9dcb 3891 for (j = 0; j < ha->tid_cnt; ++j)
45f1a41b 3892 gdth_wait_completion(ha, i, j);
1da177e4
LT		 3893 } else {
3894 spin_lock_irqsave(&ha->smp_lock, flags);
3895 ha->raw[i].lock = 0;
3896 spin_unlock_irqrestore(&ha->smp_lock, flags);
242f9dcb 3897 for (j = 0; j < ha->tid_cnt; ++j)
45f1a41b 3898 gdth_next(ha);
1da177e4
LT		 3899 }
3900 }
3901 break;
3902 }
3903
3904 case GDTIOCTL_RESCAN:
3905 return ioc_rescan(argp, cmnd);
3906
3907 case GDTIOCTL_HDRLIST:
3908 return ioc_hdrlist(argp, cmnd);
3909
3910 case GDTIOCTL_RESET_BUS:
3911 {
3912 gdth_ioctl_reset res;
45f1a41b 3913 int rval;
1da177e4
LT		 3914
3915 if (copy_from_user(&res, argp, sizeof(gdth_ioctl_reset)) ||
884f7fba 3916 (NULL == (ha = gdth_find_ha(res.ionode))))
1da177e4 3917 return -EFAULT;
1da177e4 3918
bbfbbbc1 3919 scp = kzalloc(sizeof(*scp), GFP_KERNEL);
1da177e4
LT		 3920 if (!scp)
3921 return -ENOMEM;
cbd5f69b 3922 scp->device = ha->sdev;
1da177e4 3923 scp->cmd_len = 12;
52759e6a 3924 scp->device->channel = res.number;
1da177e4
LT		 3925 rval = gdth_eh_bus_reset(scp);
3926 res.status = (rval == SUCCESS ? S_OK : S_GENERR);
cbd5f69b 3927 kfree(scp);
8d7a5da4 3928
1da177e4
LT		 3929 if (copy_to_user(argp, &res, sizeof(gdth_ioctl_reset)))
3930 return -EFAULT;
3931 break;
3932 }
3933
3934 case GDTIOCTL_RESET_DRV:
3935 return ioc_resetdrv(argp, cmnd);
3936
3937 default:
3938 break;
3939 }
3940 return 0;
3941}
3942
f4927c45
AB		 3943static long gdth_unlocked_ioctl(struct file *file, unsigned int cmd,
3944 unsigned long arg)
3945{
3946 int ret;
3947
c45d15d2 3948 mutex_lock(&gdth_mutex);
f4927c45 3949 ret = gdth_ioctl(file, cmd, arg);
c45d15d2 3950 mutex_unlock(&gdth_mutex);
f4927c45
AB		 3951
3952 return ret;
3953}
1da177e4
LT		 3954
3955/* flush routine */
45f1a41b 3956static void gdth_flush(gdth_ha_str *ha)
1da177e4
LT		 3957{
3958 int i;
1da177e4 3959 gdth_cmd_str gdtcmd;
1da177e4
LT		 3960 char cmnd[MAX_COMMAND_SIZE];
3961 memset(cmnd, 0xff, MAX_COMMAND_SIZE);
3962
45f1a41b 3963 TRACE2(("gdth_flush() hanum %d\n", ha->hanum));
1da177e4 3964
1da177e4
LT		 3965 for (i = 0; i < MAX_HDRIVES; ++i) {
3966 if (ha->hdr[i].present) {
3967 gdtcmd.BoardNode = LOCALBOARD;
3968 gdtcmd.Service = CACHESERVICE;
3969 gdtcmd.OpCode = GDT_FLUSH;
3970 if (ha->cache_feat & GDT_64BIT) {
3971 gdtcmd.u.cache64.DeviceNo = i;
3972 gdtcmd.u.cache64.BlockNo = 1;
3973 gdtcmd.u.cache64.sg_canz = 0;
3974 } else {
3975 gdtcmd.u.cache.DeviceNo = i;
3976 gdtcmd.u.cache.BlockNo = 1;
3977 gdtcmd.u.cache.sg_canz = 0;
3978 }
45f1a41b 3979 TRACE2(("gdth_flush(): flush ha %d drive %d\n", ha->hanum, i));
cbd5f69b 3980
45f1a41b 3981 gdth_execute(ha->shost, &gdtcmd, cmnd, 30, NULL);
1da177e4
LT		 3982 }
3983 }
1da177e4
LT		 3984}
3985
cbd5f69b
LA		 3986/* configure lun */
3987static int gdth_slave_configure(struct scsi_device *sdev)
3988{
cbd5f69b
LA		 3989 sdev->skip_ms_page_3f = 1;
3990 sdev->skip_ms_page_8 = 1;
3991 return 0;
3992}
cbd5f69b 3993
835cc24a 3994static struct scsi_host_template gdth_template = {
1da177e4 3995 .name = "GDT SCSI Disk Array Controller",
1da177e4
LT		 3996 .info = gdth_info,
3997 .queuecommand = gdth_queuecommand,
1da177e4 3998 .eh_bus_reset_handler = gdth_eh_bus_reset,
69916b7c 3999 .slave_configure = gdth_slave_configure,
1da177e4 4000 .bios_param = gdth_bios_param,
3e0552ee
AV		 4001 .show_info = gdth_show_info,
4002 .write_info = gdth_set_info,
242f9dcb 4003 .eh_timed_out = gdth_timed_out,
69916b7c 4004 .proc_name = "gdth",
1da177e4
LT		 4005 .can_queue = GDTH_MAXCMDS,
4006 .this_id = -1,
4007 .sg_tablesize = GDTH_MAXSG,
4008 .cmd_per_lun = GDTH_MAXC_P_L,
4009 .unchecked_isa_dma = 1,
54b2b50c 4010 .no_write_same = 1,
1da177e4
LT		 4011};
4012
6f039790 4013static int gdth_pci_probe_one(gdth_pci_str *pcistr, gdth_ha_str **ha_out)
8514ef27
CH		 4014{
4015 struct Scsi_Host *shp;
4016 gdth_ha_str *ha;
4017 dma_addr_t scratch_dma_handle = 0;
884f7fba 4018 int error, i;
4c9c8d78 4019 struct pci_dev *pdev = pcistr->pdev;
8514ef27 4020
cff26806
JG		 4021 *ha_out = NULL;
4022
835cc24a 4023 shp = scsi_host_alloc(&gdth_template, sizeof(gdth_ha_str));
8514ef27
CH		 4024 if (!shp)
4025 return -ENOMEM;
45f1a41b 4026 ha = shost_priv(shp);
8514ef27
CH		 4027
4028 error = -ENODEV;
4c9c8d78 4029 if (!gdth_init_pci(pdev, pcistr, ha))
8514ef27
CH		 4030 goto out_host_put;
4031
4032 /* controller found and initialized */
4033 printk("Configuring GDT-PCI HA at %d/%d IRQ %u\n",
4c9c8d78
JG		 4034 pdev->bus->number,
4035 PCI_SLOT(pdev->devfn),
8514ef27
CH		 4036 ha->irq);
4037
4038 error = request_irq(ha->irq, gdth_interrupt,
4909cc2b 4039 IRQF_SHARED, "gdth", ha);
8514ef27
CH		 4040 if (error) {
4041 printk("GDT-PCI: Unable to allocate IRQ\n");
4042 goto out_host_put;
4043 }
4044
4045 shp->unchecked_isa_dma = 0;
4046 shp->irq = ha->irq;
4047 shp->dma_channel = 0xff;
8514ef27 4048
884f7fba 4049 ha->hanum = gdth_ctr_count++;
45f1a41b 4050 ha->shost = shp;
8514ef27 4051
45f1a41b 4052 ha->pccb = &ha->cmdext;
8514ef27
CH		 4053 ha->ccb_phys = 0L;
4054
4055 error = -ENOMEM;
4056
bb327df8
CH		 4057 ha->pscratch = dma_alloc_coherent(&ha->pdev->dev, GDTH_SCRATCH,
4058 &scratch_dma_handle, GFP_KERNEL);
8514ef27
CH		 4059 if (!ha->pscratch)
4060 goto out_free_irq;
4061 ha->scratch_phys = scratch_dma_handle;
4062
bb327df8
CH		 4063 ha->pmsg = dma_alloc_coherent(&ha->pdev->dev, sizeof(gdth_msg_str),
4064 &scratch_dma_handle, GFP_KERNEL);
8514ef27
CH		 4065 if (!ha->pmsg)
4066 goto out_free_pscratch;
4067 ha->msg_phys = scratch_dma_handle;
4068
8514ef27
CH		 4069 ha->scratch_busy = FALSE;
4070 ha->req_first = NULL;
4c9c8d78 4071 ha->tid_cnt = pdev->device >= 0x200 ? MAXID : MAX_HDRIVES;
8514ef27
CH		 4072 if (max_ids > 0 && max_ids < ha->tid_cnt)
4073 ha->tid_cnt = max_ids;
4074 for (i = 0; i < GDTH_MAXCMDS; ++i)
4075 ha->cmd_tab[i].cmnd = UNUSED_CMND;
4076 ha->scan_mode = rescan ? 0x10 : 0;
4077
4078 error = -ENODEV;
45f1a41b
BH		 4079 if (!gdth_search_drives(ha)) {
4080 printk("GDT-PCI %d: Error during device scan\n", ha->hanum);
d8e1e6ad 4081 goto out_free_pmsg;
8514ef27
CH		 4082 }
4083
4084 if (hdr_channel < 0 || hdr_channel > ha->bus_cnt)
4085 hdr_channel = ha->bus_cnt;
4086 ha->virt_bus = hdr_channel;
4087
4088 /* 64-bit DMA only supported from FW >= x.43 */
4089 if (!(ha->cache_feat & ha->raw_feat & ha->screen_feat & GDT_64BIT) ||
4090 !ha->dma64_support) {
bb327df8 4091 if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
8514ef27 4092 printk(KERN_WARNING "GDT-PCI %d: "
45f1a41b 4093 "Unable to set 32-bit DMA\n", ha->hanum);
d8e1e6ad 4094 goto out_free_pmsg;
8514ef27
CH		 4095 }
4096 } else {
4097 shp->max_cmd_len = 16;
bb327df8 4098 if (!dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
45f1a41b 4099 printk("GDT-PCI %d: 64-bit DMA enabled\n", ha->hanum);
bb327df8 4100 } else if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
8514ef27 4101 printk(KERN_WARNING "GDT-PCI %d: "
45f1a41b 4102 "Unable to set 64/32-bit DMA\n", ha->hanum);
d8e1e6ad 4103 goto out_free_pmsg;
8514ef27
CH		 4104 }
4105 }
4106
4107 shp->max_id = ha->tid_cnt;
4108 shp->max_lun = MAXLUN;
52759e6a 4109 shp->max_channel = ha->bus_cnt;
8514ef27
CH		 4110
4111 spin_lock_init(&ha->smp_lock);
45f1a41b 4112 gdth_enable_int(ha);
835cc24a 4113
4c9c8d78 4114 error = scsi_add_host(shp, &pdev->dev);
835cc24a 4115 if (error)
d8e1e6ad 4116 goto out_free_pmsg;
835cc24a 4117 list_add_tail(&ha->list, &gdth_instances);
61c92814 4118
cff26806 4119 pci_set_drvdata(ha->pdev, ha);
2d6f0d0c 4120 gdth_timer_init();
cff26806 4121
61c92814
BH		 4122 scsi_scan_host(shp);
4123
cff26806
JG		 4124 *ha_out = ha;
4125
8514ef27
CH		 4126 return 0;
4127
8514ef27 4128 out_free_pmsg:
bb327df8 4129 dma_free_coherent(&ha->pdev->dev, sizeof(gdth_msg_str),
8514ef27
CH		 4130 ha->pmsg, ha->msg_phys);
4131 out_free_pscratch:
bb327df8 4132 dma_free_coherent(&ha->pdev->dev, GDTH_SCRATCH,
8514ef27
CH		 4133 ha->pscratch, ha->scratch_phys);
4134 out_free_irq:
4135 free_irq(ha->irq, ha);
4136 gdth_ctr_count--;
8514ef27 4137 out_host_put:
835cc24a 4138 scsi_host_put(shp);
8514ef27
CH		 4139 return error;
4140}
8514ef27 4141
835cc24a
CH		 4142static void gdth_remove_one(gdth_ha_str *ha)
4143{
4144 struct Scsi_Host *shp = ha->shost;
4145
4146 TRACE2(("gdth_remove_one()\n"));
4147
4148 scsi_remove_host(shp);
4149
b31ddd31
BH		 4150 gdth_flush(ha);
4151
835cc24a
CH		 4152 if (ha->sdev) {
4153 scsi_free_host_dev(ha->sdev);
4154 ha->sdev = NULL;
4155 }
4156
835cc24a
CH		 4157 if (shp->irq)
4158 free_irq(shp->irq,ha);
4159
835cc24a 4160 if (ha->pscratch)
bb327df8 4161 dma_free_coherent(&ha->pdev->dev, GDTH_SCRATCH,
835cc24a
CH		 4162 ha->pscratch, ha->scratch_phys);
4163 if (ha->pmsg)
bb327df8 4164 dma_free_coherent(&ha->pdev->dev, sizeof(gdth_msg_str),
835cc24a
CH		 4165 ha->pmsg, ha->msg_phys);
4166 if (ha->ccb_phys)
bb327df8
CH		 4167 dma_unmap_single(&ha->pdev->dev, ha->ccb_phys,
4168 sizeof(gdth_cmd_str), DMA_BIDIRECTIONAL);
835cc24a
CH		 4169
4170 scsi_host_put(shp);
4171}
4172
1fe6dbf4 4173static int gdth_halt(struct notifier_block *nb, unsigned long event, void *buf)
b31ddd31
BH		 4174{
4175 gdth_ha_str *ha;
4176
4177 TRACE2(("gdth_halt() event %d\n", (int)event));
4178 if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF)
4179 return NOTIFY_DONE;
4180
4181 list_for_each_entry(ha, &gdth_instances, list)
4182 gdth_flush(ha);
4183
4184 return NOTIFY_OK;
4185}
4186
4187static struct notifier_block gdth_notifier = {
4188 gdth_halt, NULL, 0
4189};
4190
835cc24a
CH		 4191static int __init gdth_init(void)
4192{
4193 if (disable) {
4194 printk("GDT-HA: Controller driver disabled from"
4195 " command line !\n");
4196 return 0;
4197 }
4198
4199 printk("GDT-HA: Storage RAID Controller Driver. Version: %s\n",
4200 GDTH_VERSION_STR);
4201
4202 /* initializations */
4203 gdth_polling = TRUE;
4204 gdth_clear_events();
7932589f 4205 timer_setup(&gdth_timer, gdth_timeout, 0);
835cc24a 4206
835cc24a 4207 /* scanning for PCI controllers */
a85591fd
JB		 4208 if (pci_register_driver(&gdth_pci_driver)) {
4209 gdth_ha_str *ha;
4210
4211 list_for_each_entry(ha, &gdth_instances, list)
4212 gdth_remove_one(ha);
4213 return -ENODEV;
4214 }
835cc24a
CH		 4215
4216 TRACE2(("gdth_detect() %d controller detected\n", gdth_ctr_count));
c596cc46 4217
835cc24a 4218 major = register_chrdev(0,"gdth", &gdth_fops);
835cc24a
CH		 4219 register_reboot_notifier(&gdth_notifier);
4220 gdth_polling = FALSE;
4221 return 0;
4222}
4223
4224static void __exit gdth_exit(void)
4225{
4226 gdth_ha_str *ha;
4227
b31ddd31
BH		 4228 unregister_chrdev(major, "gdth");
4229 unregister_reboot_notifier(&gdth_notifier);
835cc24a
CH		 4230
4231#ifdef GDTH_STATISTICS
b31ddd31 4232 del_timer_sync(&gdth_timer);
835cc24a 4233#endif
b31ddd31 4234
a85591fd 4235 pci_unregister_driver(&gdth_pci_driver);
cff26806 4236
b31ddd31
BH		 4237 list_for_each_entry(ha, &gdth_instances, list)
4238 gdth_remove_one(ha);
835cc24a
CH		 4239}
4240
4241module_init(gdth_init);
4242module_exit(gdth_exit);
4243
1da177e4 4244#ifndef MODULE
938b9e9f
JY		 4245static void __init internal_setup(char *str,int *ints)
4246{
4247 int i;
4248 char *cur_str, *argv;
4249
4250 TRACE2(("internal_setup() str %s ints[0] %d\n",
4251 str ? str:"NULL", ints ? ints[0]:0));
4252
4253 /* analyse string */
4254 argv = str;
4255 while (argv && (cur_str = strchr(argv, ':'))) {
4256 int val = 0, c = *++cur_str;
4257
4258 if (c == 'n' || c == 'N')
4259 val = 0;
4260 else if (c == 'y' || c == 'Y')
4261 val = 1;
4262 else
4263 val = (int)simple_strtoul(cur_str, NULL, 0);
4264
4265 if (!strncmp(argv, "disable:", 8))
4266 disable = val;
4267 else if (!strncmp(argv, "reserve_mode:", 13))
4268 reserve_mode = val;
4269 else if (!strncmp(argv, "reverse_scan:", 13))
4270 reverse_scan = val;
4271 else if (!strncmp(argv, "hdr_channel:", 12))
4272 hdr_channel = val;
4273 else if (!strncmp(argv, "max_ids:", 8))
4274 max_ids = val;
4275 else if (!strncmp(argv, "rescan:", 7))
4276 rescan = val;
4277 else if (!strncmp(argv, "shared_access:", 14))
4278 shared_access = val;
4279 else if (!strncmp(argv, "reserve_list:", 13)) {
4280 reserve_list[0] = val;
4281 for (i = 1; i < MAX_RES_ARGS; i++) {
4282 cur_str = strchr(cur_str, ',');
4283 if (!cur_str)
4284 break;
4285 if (!isdigit((int)*++cur_str)) {
4286 --cur_str;
4287 break;
4288 }
4289 reserve_list[i] =
4290 (int)simple_strtoul(cur_str, NULL, 0);
4291 }
4292 if (!cur_str)
4293 break;
4294 argv = ++cur_str;
4295 continue;
4296 }
4297
4298 if ((argv = strchr(argv, ',')))
4299 ++argv;
4300 }
4301}
4302
4303static int __init option_setup(char *str)
4304{
4305 int ints[MAXHA];
4306 char *cur = str;
4307 int i = 1;
4308
4309 TRACE2(("option_setup() str %s\n", str ? str:"NULL"));
4310
4311 while (cur && isdigit(*cur) && i < MAXHA) {
4312 ints[i++] = simple_strtoul(cur, NULL, 0);
4313 if ((cur = strchr(cur, ',')) != NULL) cur++;
4314 }
4315
4316 ints[0] = i - 1;
4317 internal_setup(cur, ints);
4318 return 1;
4319}
4320
1da177e4
LT		 4321__setup("gdth=", option_setup);
4322#endif
Ubuntu Hirsute Linux kernel mirror