dminit.c revision 285809 
1/*******************************************************************************
2**
3*Copyright (c) 2014 PMC-Sierra, Inc.  All rights reserved.
4*
5*Redistribution and use in source and binary forms, with or without modification, are permitted provided
6*that the following conditions are met:
7*1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
8*following disclaimer.
9*2. Redistributions in binary form must reproduce the above copyright notice,
10*this list of conditions and the following disclaimer in the documentation and/or other materials provided
11*with the distribution.
12*
13*THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
14*WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
15*FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
16*FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
17*NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
18*BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
19*LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
20*SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
21
22********************************************************************************/
23#include <sys/cdefs.h>
24__FBSDID("$FreeBSD$");
25#include <dev/pms/config.h>
26
27#include <dev/pms/freebsd/driver/common/osenv.h>
28#include <dev/pms/freebsd/driver/common/ostypes.h>
29#include <dev/pms/freebsd/driver/common/osdebug.h>
30
31#include <dev/pms/RefTisa/sallsdk/api/sa.h>
32#include <dev/pms/RefTisa/sallsdk/api/saapi.h>
33#include <dev/pms/RefTisa/sallsdk/api/saosapi.h>
34
35#ifdef FDS_DM
36#include <dev/pms/RefTisa/discovery/api/dm.h>
37#include <dev/pms/RefTisa/discovery/api/dmapi.h>
38#include <dev/pms/RefTisa/discovery/api/tddmapi.h>
39
40#include <dev/pms/RefTisa/discovery/dm/dmdefs.h>
41#include <dev/pms/RefTisa/discovery/dm/dmtypes.h>
42#include <dev/pms/RefTisa/discovery/dm/dmproto.h>
43
44#ifdef DM_DEBUG
45bit32 gDMDebugLevel = 1;
46#endif
47
48osGLOBAL void
49dmGetRequirements(
50                  dmRoot_t 	  		*dmRoot,
51                  dmSwConfig_t			*swConfig,
52                  dmMemoryRequirement_t		*memoryRequirement,
53                  bit32 			*usecsPerTick,
54                  bit32				*maxNumLocks)
55{
56  bit32               memoryReqCount = 0;
57  bit32               max_expander = DM_MAX_EXPANDER_DEV;
58  char    *buffer;
59  bit32   buffLen;
60  bit32   lenRecv = 0;
61  static char    tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
62  char    *pLastUsedChar = agNULL;
63  char    globalStr[]     = "Global";
64  char    iniParmsStr[]   = "InitiatorParms";
65  char    SwParmsStr[]    = "SWParms";
66
67  DM_DBG3(("dmGetRequirements: start\n"));
68  /* sanity check */
69  DM_ASSERT((agNULL != swConfig), "");
70  DM_ASSERT((agNULL != memoryRequirement), "");
71  DM_ASSERT((agNULL != usecsPerTick), "");
72  DM_ASSERT((agNULL != maxNumLocks), "");
73
74  /* memory requirement for dmRoot, CACHE memory */
75  memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].singleElementLength = sizeof(dmIntRoot_t);
76  memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].numElements = 1;
77  memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].totalLength =
78      (memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].numElements);
79  memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].alignment = 4;
80  memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].type = DM_CACHED_MEM;
81  memoryReqCount++;
82
83  /* memory requirement for Port Context Links, CACHE memory */
84  memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].singleElementLength = sizeof(dmIntPortContext_t);
85  memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].numElements = DM_MAX_PORT_CONTEXT;
86  memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].totalLength =
87      (memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].numElements);
88  memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].alignment = 4;
89  memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].type = DM_CACHED_MEM;
90  memoryReqCount++;
91
92  /* memory requirement for Device Links, CACHE memory */
93  memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].singleElementLength = sizeof(dmDeviceData_t);
94  memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].numElements = DM_MAX_DEV;
95  memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].totalLength =
96      (memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].numElements);
97  memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].alignment = 4;
98  memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].type = DM_CACHED_MEM;
99  memoryReqCount++;
100
101  /* memory requirement for Expander Device Links, CACHE memory */
102  /*
103     Maximum number of expanders are configurable
104     The default is DM_MAX_EXPANDER_DEV
105  */
106  buffer = tmpBuffer;
107  buffLen = sizeof(tmpBuffer);
108
109  dm_memset(buffer, 0, buffLen);
110  lenRecv = 0;
111
112  if ((tddmGetTransportParam(
113                             dmRoot,
114                             globalStr,
115                             iniParmsStr,
116                             agNULL,
117                             agNULL,
118                             agNULL,
119                             agNULL,
120                             "MaxExpanders",
121                             buffer,
122                             buffLen,
123                             &lenRecv
124                             ) == DM_RC_SUCCESS) && (lenRecv != 0))
125  {
126    if (osti_strncmp(buffer, "0x", 2) == 0)
127    {
128      max_expander = osti_strtoul (buffer, &pLastUsedChar, 0);
129    }
130    else
131    {
132      max_expander = osti_strtoul (buffer, &pLastUsedChar, 10);
133    }
134  }
135  DM_DBG3(("dmGetRequirements: max_expander %d\n", max_expander));
136
137
138  memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].singleElementLength = sizeof(dmExpander_t);
139  memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].numElements = max_expander;
140  memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].totalLength =
141      (memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].numElements);
142  memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].alignment = 4;
143  memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].type = DM_CACHED_MEM;
144  memoryReqCount++;
145
146  /* memory requirement for SMP command Links, CACHE memory */
147  memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].singleElementLength = sizeof(dmSMPRequestBody_t);
148  memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].numElements = DM_MAX_SMP;
149  memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].totalLength =
150      (memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].numElements);
151  memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].alignment = 4;
152  memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].type = DM_CACHED_MEM;
153  memoryReqCount++;
154
155  /* memory requirement for INDIRECT SMP command/response Links, DMA memory */
156  memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].singleElementLength = SMP_INDIRECT_PAYLOAD; /* 512 */
157  memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].numElements = DM_MAX_INDIRECT_SMP;
158  memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].totalLength =
159      (memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].numElements);
160  memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].alignment = 4;
161  memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].type = DM_DMA_MEM;
162  memoryReqCount++;
163
164
165  /* set up memory requirement count */
166  memoryRequirement->count = memoryReqCount;
167
168  /* requirement for locks */
169  *maxNumLocks = DM_MAX_LOCKS;
170
171  /* setup the time tick */
172  *usecsPerTick = DM_USECS_PER_TICK;
173
174
175  /* set up the number of Expander device handles */
176  swConfig->numDevHandles = DM_MAX_DEV;
177  swConfig->itNexusTimeout = IT_NEXUS_TIMEOUT;   /* default is 2000 ms*/
178
179  dm_memset(buffer, 0, buffLen);
180  lenRecv = 0;
181
182  if ((tddmGetTransportParam(
183                             dmRoot,
184                             globalStr,
185                             SwParmsStr,
186                             agNULL,
187                             agNULL,
188                             agNULL,
189                             agNULL,
190                             "IT_NEXUS_TIMEOUT",
191                             buffer,
192                             buffLen,
193                             &lenRecv
194                             ) == DM_RC_SUCCESS) && (lenRecv != 0))
195  {
196    if (osti_strncmp(buffer, "0x", 2) == 0)
197    {
198      swConfig->itNexusTimeout = osti_strtoul (buffer, &pLastUsedChar, 0);
199    }
200    else
201    {
202      swConfig->itNexusTimeout = osti_strtoul (buffer, &pLastUsedChar, 10);
203    }
204  }
205
206  DM_DBG1(("dmGetRequirements: swConfig->itNexusTimeout 0x%X\n", swConfig->itNexusTimeout));
207
208  DM_DBG3(("dmGetRequirements: memoryReqCount %d\n", memoryRequirement->count));
209
210  return;
211}
212/*
213  ??? processing swConfig
214*/
215osGLOBAL bit32
216dmInitialize(
217             dmRoot_t			*dmRoot,
218             agsaRoot_t                 *agRoot,
219             dmMemoryRequirement_t	*memoryAllocated,
220             dmSwConfig_t		*swConfig,
221             bit32			usecsPerTick )
222{
223  dmIntRoot_t               *dmIntRoot;
224  dmIntPortContext_t        *dmIntPortContext;
225  dmDeviceData_t            *dmDevice;
226  dmExpander_t              *dmExpander;
227  dmSMPRequestBody_t        *dmSMPRequest;
228  bit8                      *dmIndirectSMPRequest;
229  dmIntContext_t            *dmAllShared;
230  bit32              i;
231  bit32               max_expander = DM_MAX_EXPANDER_DEV;
232  char    *buffer;
233  bit32   buffLen;
234  bit32   lenRecv = 0;
235  static char    tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
236  char    *pLastUsedChar = agNULL;
237  char    globalStr[]     = "Global";
238  char    iniParmsStr[]   = "InitiatorParms";
239  char    SwParmsStr[]    = "SWParms";
240
241  DM_DBG3(("dmInitialize: start\n"));
242  /* sanity check */
243  DM_ASSERT((agNULL != dmRoot), "");
244  DM_ASSERT((agNULL != agRoot), "");
245  DM_ASSERT((agNULL != memoryAllocated), "");
246  DM_ASSERT((agNULL != swConfig), "");
247  DM_ASSERT((DM_ROOT_MEM_INDEX < memoryAllocated->count), "");
248  DM_ASSERT((DM_PORT_MEM_INDEX < memoryAllocated->count), "");
249  DM_ASSERT((DM_DEVICE_MEM_INDEX < memoryAllocated->count), "");
250  DM_ASSERT((DM_EXPANDER_MEM_INDEX < memoryAllocated->count), "");
251  DM_ASSERT((DM_SMP_MEM_INDEX < memoryAllocated->count), "");
252  DM_ASSERT((DM_INDIRECT_SMP_MEM_INDEX < memoryAllocated->count), "");
253
254  /* Check the memory allocated */
255  for ( i = 0; i < memoryAllocated->count; i ++ )
256  {
257    /* If memory allocatation failed  */
258    if (memoryAllocated->dmMemory[i].singleElementLength &&
259        memoryAllocated->dmMemory[i].numElements)
260    {
261      if ( (0 != memoryAllocated->dmMemory[i].numElements)
262          && (0 == memoryAllocated->dmMemory[i].totalLength) )
263      {
264        /* return failure */
265        DM_DBG1(("dmInitialize: Memory[%d]  singleElementLength = 0x%0x  numElements = 0x%x NOT allocated!!!\n",
266          i,
267          memoryAllocated->dmMemory[i].singleElementLength,
268          memoryAllocated->dmMemory[i].numElements));
269        return DM_RC_FAILURE;
270      }
271    }
272  }
273
274  /* DM's internal root */
275  dmIntRoot  = (dmIntRoot_t *) (memoryAllocated->dmMemory[DM_ROOT_MEM_INDEX].virtPtr);
276  dmRoot->dmData = (void *) dmIntRoot;
277
278  dmAllShared = (dmIntContext_t *)&(dmIntRoot->dmAllShared);
279  /**<  Initialize the TDM data part of the interrupt context */
280  dmAllShared->dmRootOsData.dmRoot     = dmRoot;
281  dmAllShared->dmRootOsData.dmAllShared   = (void *) dmAllShared;
282
283  /* Port Contexts */
284  dmIntPortContext = (dmIntPortContext_t *) (memoryAllocated->dmMemory[DM_PORT_MEM_INDEX].virtPtr);
285  dmAllShared->PortContextMem = (dmIntPortContext_t *)dmIntPortContext;
286
287  /* Devices */
288  dmDevice = (dmDeviceData_t *) (memoryAllocated->dmMemory[DM_DEVICE_MEM_INDEX].virtPtr);
289  dmAllShared->DeviceMem = (dmDeviceData_t *)dmDevice;
290
291  /* Expanders */
292  dmExpander = (dmExpander_t *) (memoryAllocated->dmMemory[DM_EXPANDER_MEM_INDEX].virtPtr);
293  dmAllShared->ExpanderMem = (dmExpander_t *)dmExpander;
294
295  /* SMP commands */
296  dmSMPRequest = (dmSMPRequestBody_t *) (memoryAllocated->dmMemory[DM_SMP_MEM_INDEX].virtPtr);
297  dmAllShared->SMPMem = (dmSMPRequestBody_t *)dmSMPRequest;
298
299  /* DMAable SMP request/reponse pointed by dmSMPRequestBody_t */
300  dmIndirectSMPRequest = (bit8 *) (memoryAllocated->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].virtPtr);
301  dmAllShared->IndirectSMPMem = (bit8 *)dmIndirectSMPRequest;
302  dmAllShared->IndirectSMPUpper32 = memoryAllocated->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].physAddrUpper;
303  dmAllShared->IndirectSMPLower32 = memoryAllocated->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].physAddrLower;
304
305  dmAllShared->agRoot = agRoot;
306
307
308  dmAllShared->usecsPerTick = usecsPerTick;
309  dmAllShared->itNexusTimeout = IT_NEXUS_TIMEOUT;/*swConfig->itNexusTimeout;*/
310  dmAllShared->MaxRetryDiscovery = DISCOVERY_RETRIES;
311  dmAllShared->RateAdjust = 0;
312  /**< initializes timers */
313  dmInitTimers(dmRoot);
314
315  /**< initializes port contexts */
316  dmPortContextInit(dmRoot);
317
318  /**< initializes devices */
319  dmDeviceDataInit(dmRoot);
320
321  /**< initializes expander devices */
322  buffer = tmpBuffer;
323  buffLen = sizeof(tmpBuffer);
324
325  dm_memset(buffer, 0, buffLen);
326  lenRecv = 0;
327
328  if ((tddmGetTransportParam(
329                             dmRoot,
330                             globalStr,
331                             iniParmsStr,
332                             agNULL,
333                             agNULL,
334                             agNULL,
335                             agNULL,
336                             "MaxExpanders",
337                             buffer,
338                             buffLen,
339                             &lenRecv
340                             ) == DM_RC_SUCCESS) && (lenRecv != 0))
341  {
342    if (osti_strncmp(buffer, "0x", 2) == 0)
343    {
344      max_expander = osti_strtoul (buffer, &pLastUsedChar, 0);
345    }
346    else
347    {
348      max_expander = osti_strtoul (buffer, &pLastUsedChar, 10);
349    }
350  }
351
352  dm_memset(buffer, 0, buffLen);
353  lenRecv = 0;
354
355  if ((tddmGetTransportParam(
356                             dmRoot,
357                             globalStr,
358                             SwParmsStr,
359                             agNULL,
360                             agNULL,
361                             agNULL,
362                             agNULL,
363                             "IT_NEXUS_TIMEOUT",
364                             buffer,
365                             buffLen,
366                             &lenRecv
367                             ) == DM_RC_SUCCESS) && (lenRecv != 0))
368  {
369    if (osti_strncmp(buffer, "0x", 2) == 0)
370    {
371      dmAllShared->itNexusTimeout = osti_strtoul (buffer, &pLastUsedChar, 0);
372    }
373    else
374    {
375      dmAllShared->itNexusTimeout = osti_strtoul (buffer, &pLastUsedChar, 10);
376    }
377  }
378
379  DM_DBG1(("dmAllShared->itNexusTimeout %d \n", dmAllShared->itNexusTimeout));
380
381  dm_memset(buffer, 0, buffLen);
382  lenRecv = 0;
383
384  if ((tddmGetTransportParam(
385                             dmRoot,
386                             globalStr,
387                             SwParmsStr,
388                             agNULL,
389                             agNULL,
390                             agNULL,
391                             agNULL,
392                             "MaxRetryDiscovery",
393                             buffer,
394                             buffLen,
395                             &lenRecv
396                             ) == DM_RC_SUCCESS) && (lenRecv != 0))
397  {
398    if (osti_strncmp(buffer, "0x", 2) == 0)
399    {
400      dmAllShared->MaxRetryDiscovery = osti_strtoul (buffer, &pLastUsedChar, 0);
401    }
402    else
403    {
404      dmAllShared->MaxRetryDiscovery = osti_strtoul (buffer, &pLastUsedChar, 10);
405    }
406  }
407
408  DM_DBG1(("dmAllShared->MaxRetryDiscovery %d \n", dmAllShared->MaxRetryDiscovery));
409
410  dm_memset(buffer, 0, buffLen);
411  lenRecv = 0;
412  if ((tddmGetTransportParam(
413                             dmRoot,
414                             globalStr,
415                             SwParmsStr,
416                             agNULL,
417                             agNULL,
418                             agNULL,
419                             agNULL,
420                             "RateAdjust",
421                             buffer,
422                             buffLen,
423                             &lenRecv
424                             ) == DM_RC_SUCCESS) && (lenRecv != 0))
425  {
426    if (osti_strncmp(buffer, "0x", 2) == 0)
427    {
428      dmAllShared->RateAdjust = osti_strtoul (buffer, &pLastUsedChar, 0);
429    }
430    else
431    {
432      dmAllShared->RateAdjust = osti_strtoul (buffer, &pLastUsedChar, 10);
433    }
434  }
435  DM_DBG1(("dmAllShared->RateAdjust %d \n", dmAllShared->RateAdjust));
436
437  dmExpanderDeviceDataInit(dmRoot, max_expander);
438
439  /**< initializes SMP commands */
440  dmSMPInit(dmRoot);
441
442#ifdef DM_DEBUG
443  gDMDebugLevel = swConfig->DMDebugLevel;
444#endif
445  return DM_RC_SUCCESS;
446}
447
448osGLOBAL void
449dmSMPInit(
450          dmRoot_t *dmRoot
451         )
452{
453  dmIntRoot_t               *dmIntRoot    = (dmIntRoot_t *)dmRoot->dmData;
454  dmIntContext_t            *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
455  dmSMPRequestBody_t        *dmSMPCommand = (dmSMPRequestBody_t *)dmAllShared->SMPMem;
456  bit8                      *dmIndirectSMPReqRsp = (bit8 *)dmAllShared->IndirectSMPMem;
457  bit32                     prev_PhysAddrLower;
458
459  int i = 0;
460  DM_DBG3(("dmSMPInit: start \n"));
461
462  DMLIST_INIT_HDR(&(dmAllShared->freeSMPList));
463
464  for(i=0;i<DM_MAX_SMP;i++)
465  {
466    DMLIST_INIT_ELEMENT(&(dmSMPCommand[i].Link));
467    /* initialize expander fields */
468    dmSMPCommand[i].dmRoot = agNULL;
469    dmSMPCommand[i].dmDevice = agNULL;
470    dmSMPCommand[i].dmPortContext = agNULL;
471    dmSMPCommand[i].retries = 0;
472    dmSMPCommand[i].id = i;
473    dm_memset( &(dmSMPCommand[i].smpPayload), 0, sizeof(dmSMPCommand[i].smpPayload));
474    /* indirect SMP related */
475    dmSMPCommand[i].IndirectSMPResponse = agNULL;
476    dmSMPCommand[i].IndirectSMP = ((bit8 *)dmIndirectSMPReqRsp) + (i*SMP_INDIRECT_PAYLOAD);
477    dmSMPCommand[i].IndirectSMPUpper32 = dmAllShared->IndirectSMPUpper32;
478    dmSMPCommand[i].IndirectSMPLower32 = dmAllShared->IndirectSMPLower32;
479
480    prev_PhysAddrLower = dmAllShared->IndirectSMPLower32;
481    dmAllShared->IndirectSMPLower32 = dmAllShared->IndirectSMPLower32 + SMP_INDIRECT_PAYLOAD;
482    if (dmAllShared->IndirectSMPLower32 <= prev_PhysAddrLower)
483    {
484      dmAllShared->IndirectSMPUpper32++;
485    }
486
487    DMLIST_ENQUEUE_AT_TAIL(&(dmSMPCommand[i].Link), &(dmAllShared->freeSMPList));
488  }
489  return;
490
491}
492
493osGLOBAL void
494dmDeviceDataInit(
495                 dmRoot_t *dmRoot
496                )
497{
498  dmIntRoot_t               *dmIntRoot    = (dmIntRoot_t *)dmRoot->dmData;
499  dmIntContext_t            *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
500  dmDeviceData_t            *dmDeviceData = (dmDeviceData_t *)dmAllShared->DeviceMem;
501  int i;
502
503  DM_DBG3(("dmDeviceDataInit: start \n"));
504
505  DMLIST_INIT_HDR(&(dmAllShared->MainDeviceList));
506  DMLIST_INIT_HDR(&(dmAllShared->FreeDeviceList));
507
508  for(i=0;i<DM_MAX_DEV;i++)
509  {
510    DMLIST_INIT_ELEMENT(&(dmDeviceData[i].FreeLink));
511    DMLIST_INIT_ELEMENT(&(dmDeviceData[i].MainLink));
512    DMLIST_INIT_ELEMENT(&(dmDeviceData[i].IncDisLink));
513    dmDeviceData[i].id = i;
514    dmDeviceData[i].DeviceType = DM_DEFAULT_DEVICE;
515    dmDeviceData[i].dmRoot = agNULL;
516//    dmDeviceData[i].agDevHandle = agNULL;
517
518    dmDeviceData[i].dmPortContext = agNULL;
519    dmDeviceData[i].dmExpander = agNULL;
520    dmDeviceData[i].ExpDevice = agNULL;
521    dmDeviceData[i].phyID = 0xFF;
522    dmDeviceData[i].SASAddressID.sasAddressHi = 0;
523    dmDeviceData[i].SASAddressID.sasAddressLo = 0;
524    dmDeviceData[i].valid = agFALSE;
525    dmDeviceData[i].valid2 = agFALSE;
526    dmDeviceData[i].processed = agFALSE;
527    dmDeviceData[i].initiator_ssp_stp_smp = 0;
528    dmDeviceData[i].target_ssp_stp_smp = 0;
529    dmDeviceData[i].numOfPhys = 0;
530//    dmDeviceData[i].registered = agFALSE;
531    dmDeviceData[i].directlyAttached = agFALSE;
532    dmDeviceData[i].SASSpecDeviceType = 0xFF;
533    dmDeviceData[i].IOStart = 0;
534    dmDeviceData[i].IOResponse = 0;
535    dmDeviceData[i].agDeviceResetContext.osData = agNULL;
536    dmDeviceData[i].agDeviceResetContext.sdkData = agNULL;
537    dmDeviceData[i].TRflag = agFALSE;
538    dmDeviceData[i].ResetCnt = 0;
539    dmDeviceData[i].registered = agFALSE;
540    dmDeviceData[i].reported = agFALSE;
541
542    dmDeviceData[i].MCN = 0;
543    dmDeviceData[i].MCNDone = agFALSE;
544    dmDeviceData[i].PrevMCN = 0;
545
546    dm_memset( &(dmDeviceData[i].dmDeviceInfo), 0, sizeof(dmDeviceInfo_t));
547    /* some other variables */
548    DMLIST_ENQUEUE_AT_TAIL(&(dmDeviceData[i].FreeLink), &(dmAllShared->FreeDeviceList));
549  }
550
551  return;
552}
553osGLOBAL void
554dmDeviceDataReInit(
555                   dmRoot_t		  *dmRoot,
556                   dmDeviceData_t         *oneDeviceData
557                  )
558{
559  DM_DBG3(("dmDeviceDataReInit: start \n"));
560
561  oneDeviceData->DeviceType = DM_DEFAULT_DEVICE;
562//  oneDeviceData->agDevHandle = agNULL;
563
564  oneDeviceData->dmPortContext = agNULL;
565  oneDeviceData->dmExpander = agNULL;
566  oneDeviceData->ExpDevice = agNULL;
567  oneDeviceData->phyID = 0xFF;
568  oneDeviceData->SASAddressID.sasAddressHi = 0;
569  oneDeviceData->SASAddressID.sasAddressLo = 0;
570  oneDeviceData->valid = agFALSE;
571  oneDeviceData->valid2 = agFALSE;
572  oneDeviceData->processed = agFALSE;
573  oneDeviceData->initiator_ssp_stp_smp = 0;
574  oneDeviceData->target_ssp_stp_smp = 0;
575  oneDeviceData->numOfPhys = 0;
576//  oneDeviceData->registered = agFALSE;
577  oneDeviceData->directlyAttached = agFALSE;
578  oneDeviceData->SASSpecDeviceType = 0xFF;
579  oneDeviceData->IOStart = 0;
580  oneDeviceData->IOResponse = 0;
581  oneDeviceData->agDeviceResetContext.osData = agNULL;
582  oneDeviceData->agDeviceResetContext.sdkData = agNULL;
583  oneDeviceData->TRflag = agFALSE;
584  oneDeviceData->ResetCnt = 0;
585  oneDeviceData->registered = agFALSE;
586  oneDeviceData->reported = agFALSE;
587
588  oneDeviceData->MCN = 0;
589  oneDeviceData->MCNDone = agFALSE;
590  oneDeviceData->PrevMCN = 0;
591
592  dm_memset( &(oneDeviceData->dmDeviceInfo), 0, sizeof(dmDeviceInfo_t));
593
594  return;
595}
596
597
598osGLOBAL void
599dmExpanderDeviceDataInit(
600                         dmRoot_t *dmRoot,
601                         bit32    max_exp
602                        )
603{
604  dmIntRoot_t               *dmIntRoot    = (dmIntRoot_t *)dmRoot->dmData;
605  dmIntContext_t            *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
606  dmExpander_t              *dmExpData = (dmExpander_t *)dmAllShared->ExpanderMem;
607  bit32 i = 0;
608  DM_DBG3(("dmExpanderDeviceDataInit: start \n"));
609
610  DMLIST_INIT_HDR(&(dmAllShared->freeExpanderList));
611  DMLIST_INIT_HDR(&(dmAllShared->mainExpanderList));
612
613  for(i=0;i<max_exp;i++)
614  {
615    DMLIST_INIT_ELEMENT(&(dmExpData[i].linkNode));
616    DMLIST_INIT_ELEMENT(&(dmExpData[i].upNode));
617    /* initialize expander fields */
618    dmExpData[i].dmRoot = agNULL;
619    dmExpData[i].agDevHandle = agNULL;
620    dmExpData[i].dmDevice = agNULL;
621    dmExpData[i].dmUpStreamExpander = agNULL;
622    dmExpData[i].dmCurrentDownStreamExpander = agNULL;
623    dmExpData[i].hasUpStreamDevice = agFALSE;
624    dmExpData[i].numOfUpStreamPhys = 0;
625    dmExpData[i].currentUpStreamPhyIndex = 0;
626    dmExpData[i].numOfDownStreamPhys = 0;
627    dmExpData[i].currentDownStreamPhyIndex = 0;
628    dmExpData[i].discoveringPhyId = 0;
629    dmExpData[i].underDiscovering = agFALSE;
630    dmExpData[i].id = i;
631    DM_DBG3(("dmExpanderDeviceDataInit: exp id %d\n", i));
632
633    dmExpData[i].dmReturnginExpander = agNULL;
634    dmExpData[i].discoverSMPAllowed = agTRUE;
635    dm_memset( &(dmExpData[i].currentIndex), 0, sizeof(dmExpData[i].currentIndex));
636    dm_memset( &(dmExpData[i].upStreamPhys), 0, sizeof(dmExpData[i].upStreamPhys));
637    dm_memset( &(dmExpData[i].downStreamPhys), 0, sizeof(dmExpData[i].downStreamPhys));
638    dm_memset( &(dmExpData[i].routingAttribute), 0, sizeof(dmExpData[i].routingAttribute));
639    dmExpData[i].configSASAddrTableIndex = 0;
640    dm_memset( &(dmExpData[i].configSASAddressHiTable), 0, sizeof(dmExpData[i].configSASAddressHiTable));
641    dm_memset( &(dmExpData[i].configSASAddressLoTable), 0, sizeof(dmExpData[i].configSASAddressLoTable));
642    dmExpData[i].SAS2 = 0;  /* default is SAS 1.1 spec */
643    dmExpData[i].TTTSupported = agFALSE;  /* Table to Table is supported */
644    dmExpData[i].UndoDueToTTTSupported = agFALSE;
645
646
647    DMLIST_ENQUEUE_AT_TAIL(&(dmExpData[i].linkNode), &(dmAllShared->freeExpanderList));
648  }
649  return;
650}
651
652/* re-intialize an expander */
653osGLOBAL void
654dmExpanderDeviceDataReInit(
655                           dmRoot_t         *dmRoot,
656                           dmExpander_t     *oneExpander
657                          )
658{
659  DM_DBG3(("dmExpanderDeviceDataReInit: start \n"));
660  oneExpander->dmRoot = agNULL;
661  oneExpander->agDevHandle = agNULL;
662  oneExpander->dmDevice = agNULL;
663  oneExpander->dmUpStreamExpander = agNULL;
664  oneExpander->dmCurrentDownStreamExpander = agNULL;
665  oneExpander->hasUpStreamDevice = agFALSE;
666  oneExpander->numOfUpStreamPhys = 0;
667  oneExpander->currentUpStreamPhyIndex = 0;
668  oneExpander->numOfDownStreamPhys = 0;
669  oneExpander->currentDownStreamPhyIndex = 0;
670  oneExpander->discoveringPhyId = 0;
671  oneExpander->underDiscovering = agFALSE;
672  oneExpander->dmReturnginExpander = agNULL;
673  oneExpander->discoverSMPAllowed = agTRUE;
674  dm_memset( &(oneExpander->currentIndex), 0, sizeof(oneExpander->currentIndex));
675  dm_memset( &(oneExpander->upStreamPhys), 0, sizeof(oneExpander->upStreamPhys));
676  dm_memset( &(oneExpander->downStreamPhys), 0, sizeof(oneExpander->downStreamPhys));
677  dm_memset( &(oneExpander->routingAttribute), 0, sizeof(oneExpander->routingAttribute));
678  oneExpander->configSASAddrTableIndex = 0;
679  dm_memset( &(oneExpander->configSASAddressHiTable), 0, sizeof(oneExpander->configSASAddressHiTable));
680  dm_memset( &(oneExpander->configSASAddressLoTable), 0, sizeof(oneExpander->configSASAddressLoTable));
681  oneExpander->SAS2 = 0;  /* default is SAS 1.1 spec */
682  oneExpander->TTTSupported = agFALSE;  /* Table to Table is supported */
683  oneExpander->UndoDueToTTTSupported = agFALSE;
684
685  return;
686}
687
688osGLOBAL void
689dmPortContextInit(
690                  dmRoot_t *dmRoot
691                 )
692{
693  dmIntRoot_t               *dmIntRoot    = (dmIntRoot_t *)dmRoot->dmData;
694  dmIntContext_t            *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
695  dmIntPortContext_t        *dmPortContext = (dmIntPortContext_t *)dmAllShared->PortContextMem;
696  int i = 0;
697#ifdef TBD
698  int j = 0;
699#endif
700
701  DM_DBG3(("dmPortContextInit: start \n"));
702
703  DMLIST_INIT_HDR(&(dmAllShared->MainPortContextList));
704  DMLIST_INIT_HDR(&(dmAllShared->FreePortContextList));
705  for(i=0;i<DM_MAX_PORT_CONTEXT;i++)
706  {
707    DMLIST_INIT_ELEMENT(&(dmPortContext[i].FreeLink));
708    DMLIST_INIT_ELEMENT(&(dmPortContext[i].MainLink));
709
710    DMLIST_INIT_HDR(&(dmPortContext[i].discovery.discoveringExpanderList));
711    DMLIST_INIT_HDR(&(dmPortContext[i].discovery.UpdiscoveringExpanderList));
712    dmPortContext[i].discovery.type = DM_DISCOVERY_OPTION_FULL_START;
713    dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.discoveryTimer));
714    dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.configureRouteTimer));
715    dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.deviceRegistrationTimer));
716    dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.SMPBusyTimer));
717    dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.BCTimer));
718    dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.DiscoverySMPTimer));
719    dmPortContext[i].discovery.retries = 0;
720    dmPortContext[i].discovery.configureRouteRetries = 0;
721    dmPortContext[i].discovery.deviceRetistrationRetries = 0;
722    dmPortContext[i].discovery.pendingSMP = 0;
723    dmPortContext[i].discovery.SeenBC = agFALSE;
724    dmPortContext[i].discovery.forcedOK = agFALSE;
725    dmPortContext[i].discovery.SMPRetries = 0;
726    dmPortContext[i].discovery.DeferredError = agFALSE;
727    dmPortContext[i].discovery.ConfiguresOthers = agFALSE;
728    dmPortContext[i].discovery.ResetTriggerred = agFALSE;
729
730#ifdef INITIATOR_DRIVER
731    dmPortContext[i].DiscoveryState = DM_DSTATE_NOT_STARTED;
732    dmPortContext[i].DiscoveryAbortInProgress = agFALSE;
733    dmPortContext[i].directAttatchedSAS = agFALSE;
734    dmPortContext[i].DiscoveryRdyGiven = agFALSE;
735    dmPortContext[i].SeenLinkUp = agFALSE;
736
737#endif
738    dmPortContext[i].id = i;
739#ifdef TBD
740    dmPortContext[i].agPortContext = agNULL;
741#endif
742    dmPortContext[i].LinkRate = 0;
743    dmPortContext[i].Count = 0;
744    dmPortContext[i].valid = agFALSE;
745    dmPortContext[i].RegFailed = agFALSE;
746
747#ifdef TBD
748    for (j=0;j<DM_MAX_NUM_PHYS;j++)
749    {
750      dmPortContext[i].PhyIDList[j] = agFALSE;
751    }
752#endif
753    dmPortContext[i].RegisteredDevNums = 0;
754    dmPortContext[i].eventPhyID = 0xFF;
755    dmPortContext[i].Transient = agFALSE;
756
757    /* add more variables later */
758    DMLIST_ENQUEUE_AT_TAIL(&(dmPortContext[i].FreeLink), &(dmAllShared->FreePortContextList));
759  }
760
761#ifdef DM_INTERNAL_DEBUG  /* for debugging only */
762  for(i=0;i<DM_MAX_PORT_CONTEXT;i++)
763  {
764    DM_DBG6(("dmPortContextInit: index %d  &tdsaPortContext[] %p\n", i, &(dmPortContext[i])));
765  }
766  DM_DBG6(("dmPortContextInit: sizeof(tdsaPortContext_t) %d 0x%x\n", sizeof(dmIntPortContext_t), sizeof(dmIntPortContext_t)));
767#endif
768
769  return;
770}
771
772osGLOBAL void
773dmPortContextReInit(
774                    dmRoot_t		  *dmRoot,
775                    dmIntPortContext_t    *onePortContext
776                    )
777{
778  dmDiscovery_t   *discovery;
779
780  DM_DBG3(("dmPortContextReInit: start \n"));
781
782  discovery = &(onePortContext->discovery);
783
784  onePortContext->discovery.type = DM_DISCOVERY_OPTION_FULL_START;
785  onePortContext->discovery.retries = 0;
786  onePortContext->discovery.configureRouteRetries = 0;
787  onePortContext->discovery.deviceRetistrationRetries = 0;
788  onePortContext->discovery.pendingSMP = 0;
789  onePortContext->discovery.SeenBC = agFALSE;
790  onePortContext->discovery.forcedOK = agFALSE;
791  onePortContext->discovery.SMPRetries = 0;
792  onePortContext->discovery.DeferredError = agFALSE;
793  onePortContext->discovery.ConfiguresOthers = agFALSE;
794  onePortContext->discovery.ResetTriggerred = agFALSE;
795
796  /* free expander lists */
797  dmCleanAllExp(dmRoot, onePortContext);
798
799  /* kill the discovery-related timers if they are running */
800  tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
801  if (discovery->discoveryTimer.timerRunning == agTRUE)
802  {
803    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
804    dmKillTimer(
805                dmRoot,
806                &discovery->discoveryTimer
807               );
808  }
809  else
810  {
811    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
812  }
813
814
815  tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
816  if (discovery->configureRouteTimer.timerRunning == agTRUE)
817  {
818    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
819    dmKillTimer(
820                dmRoot,
821                &discovery->configureRouteTimer
822               );
823  }
824  else
825  {
826    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
827  }
828
829
830  tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
831  if (discovery->deviceRegistrationTimer.timerRunning == agTRUE)
832  {
833    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
834    dmKillTimer(
835                dmRoot,
836                &discovery->deviceRegistrationTimer
837               );
838  }
839  else
840  {
841    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
842  }
843
844
845  tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
846  if (discovery->BCTimer.timerRunning == agTRUE)
847  {
848    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
849    dmKillTimer(
850                dmRoot,
851                &discovery->BCTimer
852               );
853  }
854  else
855  {
856    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
857  }
858
859
860  tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
861  if (discovery->SMPBusyTimer.timerRunning == agTRUE)
862  {
863    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
864    dmKillTimer(
865                dmRoot,
866                &discovery->SMPBusyTimer
867               );
868  }
869  else
870  {
871    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
872  }
873
874
875  tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
876  if (discovery->DiscoverySMPTimer.timerRunning == agTRUE)
877  {
878    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
879    dmKillTimer(
880                dmRoot,
881                &discovery->DiscoverySMPTimer
882               );
883  }
884  else
885  {
886    tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
887  }
888
889  onePortContext->DiscoveryState = DM_DSTATE_NOT_STARTED;
890  onePortContext->DiscoveryAbortInProgress = agFALSE;
891  onePortContext->directAttatchedSAS = agFALSE;
892  onePortContext->DiscoveryRdyGiven = agFALSE;
893  onePortContext->SeenLinkUp = agFALSE;
894
895  onePortContext->dmPortContext->dmData = agNULL;
896  onePortContext->dmPortContext = agNULL;
897  onePortContext->dmRoot = agNULL;
898
899  onePortContext->LinkRate = 0;
900  onePortContext->Count = 0;
901  onePortContext->valid = agFALSE;
902  onePortContext->RegisteredDevNums = 0;
903  onePortContext->eventPhyID = 0xFF;
904  onePortContext->Transient = agFALSE;
905
906  return;
907}
908
909
910osGLOBAL void
911dmInitTimers(
912               dmRoot_t *dmRoot
913               )
914{
915  dmIntRoot_t               *dmIntRoot    = (dmIntRoot_t *)dmRoot->dmData;
916  dmIntContext_t            *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
917
918#ifdef DM_DEBUG_ENABLE
919  dmIntPortContext_t *dmPortContext = (dmIntPortContext_t *)dmAllShared->PortContextMem;
920
921  DM_DBG6(("dmInitTimers: start \n"));
922  DM_DBG6(("dmInitTimers: ******* tdsaRoot %p \n", dmIntRoot));
923  DM_DBG6(("dmInitTimers: ******* tdsaPortContext %p \n",dmPortContext));
924#endif
925
926  /* initialize the timerlist */
927  DMLIST_INIT_HDR(&(dmAllShared->timerlist));
928
929  return;
930}
931#endif /* FDS_ DM */
932
933
934