1 /*******************************************************************************
2 *Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved.
3 *
4 *Redistribution and use in source and binary forms, with or without modification, are permitted provided
5 *that the following conditions are met:
6 *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
7 *following disclaimer.
8 *2. Redistributions in binary form must reproduce the above copyright notice,
9 *this list of conditions and the following disclaimer in the documentation and/or other materials provided
10 *with the distribution.
11 *
12 *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
13 *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
14 *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
15 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
16 *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
17 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
18 *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
19 *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
20
21 *******************************************************************************/
22
23
24 MALLOC_DEFINE( M_PMC_OSTI, "osti_cacheable", "allocated from ostiAllocMemory as cacheable memory" );
25
26
27 /******************************************************************************
28 ostiAllocMemory()
29 Purpose:
30 TD layer calls to get dma memory
31 Parameters:
32 tiRoot_t *ptiRoot (IN) Pointer refers to the current root
33 void **osMemHandle (IN_OUT) Pointer To OS Mem handle to fill in
34 void **agVirtAddr (IN_OUT) Pointer to allocated memory address
35 U32 *agPhysUpper32 (IN_OUT) Pointer to Up 32 bit mem phys addr.
36 U32 *agPhysLower32 (IN_OUT) Pointer to low 32 bit mem phys addr.
37 U32 alignment (IN) Alignment requirement
38 U32 allocLength (IN) Required memory length
39 agBOOLEAN isChacheable (IN) Required memory type
40 Return:
41 tiSuccess - success
42 tiMemoryTooLarge - requested memory size too large
43 tiMemoryNotAvail - no dma memory available
44 Note:
45 for sata use.
46 where a cacheable allocation inherently may be swapped, the values
47 agPhysUpper32 and agPhysLower32 are understood to mean nothing when the
48 value isCacheable is set to true. these phys values must not be used by
49 the caller.
50 ******************************************************************************/
ostiAllocMemory(tiRoot_t * ptiRoot,void ** osMemHandle,void ** agVirtAddr,U32 * agPhysUpper32,U32 * agPhysLower32,U32 alignment,U32 allocLength,agBOOLEAN isCacheable)51 osGLOBAL U32 ostiAllocMemory( tiRoot_t *ptiRoot,
52 void **osMemHandle,
53 void **agVirtAddr,
54 U32 *agPhysUpper32,
55 U32 *agPhysLower32,
56 U32 alignment,
57 U32 allocLength,
58 agBOOLEAN isCacheable )
59 {
60 ag_card_info_t *pCardInfo = TIROOT_TO_CARDINFO( ptiRoot );
61 ag_dma_addr_t *pMem;
62 struct agtiapi_softc *pCard;
63 pCard = TIROOT_TO_CARD(ptiRoot);
64
65 AGTIAPI_PRINTK( "ostiAllocMemory: debug, cache? %d size %d alloc algn %d ### \n",
66 isCacheable, allocLength, alignment );
67
68 if( pCardInfo->topOfFreeDynamicMem == 0 ) {
69 AGTIAPI_PRINTK( "ostiAllocMemory: No space left, increase "
70 "AGTIAPI_DYNAMIC_MAX! ERROR\n" );
71 return tiMemoryNotAvail;
72 }
73
74 pMem = pCardInfo->freeDynamicMem[pCardInfo->topOfFreeDynamicMem - 1];
75
76 // where this memory has bee preallocated, be sure requirements do not
77 // exceed the limits of resources available
78 if( allocLength > 4096 ) {
79 AGTIAPI_PRINTK( "ostiAllocMemory: no-cache size 0x%x alloc NOT AVAILABLE\n",
80 allocLength );
81 return tiMemoryNotAvail;
82 }
83 if( alignment > 32 ) {
84 AGTIAPI_PRINTK( "ostiAllocMemory: no-cache alignment 0x%x NOT AVAILABLE\n",
85 alignment );
86 return tiMemoryNotAvail;
87 }
88
89 pMem->dmaPhysAddr = pMem->nocache_busaddr;
90 pMem->dmaVirtAddr = pMem->nocache_mem;
91 pMem->memSize = allocLength;
92 *agVirtAddr = pMem->dmaVirtAddr;
93
94 *agPhysUpper32 = HIGH_32_BITS( pMem->dmaPhysAddr );
95 *agPhysLower32 = LOW_32_BITS( pMem->dmaPhysAddr );
96
97 mtx_lock(&pCard->memLock);
98 pCardInfo->topOfFreeDynamicMem--;
99 *osMemHandle = (void *)pMem; // virtAddr;
100 mtx_unlock(&pCard->memLock);
101
102 return tiSuccess;
103 }
104
105 /******************************************************************************
106 ostiIOCTLWaitForSignal()
107 Purpose:
108 Function to wait semaphore during ioctl
109 Parameters:
110 tiRoot_t *ptiRoot (IN) Pointer to the current HBA
111 void **agParam1 (IN_OUT) Pointer to context to be passed
112 void **agParam2 (IN_OUT) Pointer to context to be passed
113 void **agParam (IN_OUT) Pointer to context to be passed
114 Return:
115 Note:
116 ******************************************************************************/
117 osGLOBAL void
ostiIOCTLWaitForSignal(tiRoot_t * ptiRoot,void * agParam1,void * agParam2,void * agParam3)118 ostiIOCTLWaitForSignal(tiRoot_t *ptiRoot,
119 void *agParam1,
120 void *agParam2,
121 void *agParam3)
122 {
123 struct agtiapi_softc *pCard;
124 pCard = TIROOT_TO_CARD(ptiRoot);
125
126 pCard->down_count++;
127 sema_wait (pCard->pIoctlSem);
128 }
129
130 /* Below function has to be changed to use wait for completion */
131 osGLOBAL void
ostiIOCTLWaitForComplete(tiRoot_t * ptiRoot,void * agParam1,void * agParam2,void * agParam3)132 ostiIOCTLWaitForComplete(tiRoot_t *ptiRoot,
133 void *agParam1,
134 void *agParam2,
135 void *agParam3)
136 {
137 struct agtiapi_softc *pCard;
138 pCard = TIROOT_TO_CARD(ptiRoot);
139
140 pCard->down_count++;
141 sema_wait (pCard->pIoctlSem);
142 }
143
144
145 /******************************************************************************
146 ostiChipConfigReadBit32()
147 Purpose:
148 Read 32-bit value from PCI configuration register
149 Parameters:
150 tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
151 U32 chipConfigOffset (IN) Offset to PCI configuration register
152 Return:
153 32 bit data
154 ******************************************************************************/
ostiChipConfigReadBit32(tiRoot_t * ptiRoot,U32 chipConfigOffset)155 U32 ostiChipConfigReadBit32( tiRoot_t *ptiRoot, U32 chipConfigOffset )
156 {
157 device_t lDev = TIROOT_TO_PCIDEV(ptiRoot);
158 u_int32_t lData = 0;
159
160 lData = pci_read_config( lDev, chipConfigOffset, 4 );
161
162 return (U32)lData;
163 }
164
165
166 /******************************************************************************
167 ostiChipConfigWriteBit32()
168 Purpose:
169 Write 32-bit value to PCI configuration register
170 Parameters:
171 tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
172 U32 chipConfigOffset (IN) Offset to PCI configuration register
173 U32 chipConfigValue (IN) Value to be written
174 Return: none
175 ******************************************************************************/
ostiChipConfigWriteBit32(tiRoot_t * ptiRoot,U32 chipConfigOffset,U32 chipConfigValue)176 void ostiChipConfigWriteBit32( tiRoot_t *ptiRoot,
177 U32 chipConfigOffset,
178 U32 chipConfigValue )
179 {
180 device_t lDev = TIROOT_TO_PCIDEV(ptiRoot);
181 pci_write_config( lDev, chipConfigOffset, chipConfigValue, 4 );
182 }
183
184 /******************************************************************************
185 ostiChipReadBit32()
186 Purpose:
187 Read 32-bit value from PCI address register
188 Parameters:
189 tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
190 U32 chipOffset (IN) Offset to PCI configuration register
191 Return:
192 32 bit data
193 ******************************************************************************/
ostiChipReadBit32(tiRoot_t * ptiRoot,U32 chipOffset)194 U32 ostiChipReadBit32(tiRoot_t *ptiRoot, U32 chipOffset)
195 {
196 U32 data;
197 ag_card_info_t *pCardInfo;
198
199 pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
200 data = *(U32 *)(pCardInfo->pciMemVirtAddr + chipOffset);
201 return data;
202 }
203
204 /******************************************************************************
205 ostiChipWriteBit32()
206 Purpose:
207 Write 32-bit value to PCI address register
208 Parameters:
209 tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
210 U32 chipOffset (IN) Offset to PCI configuration register
211 U32 chipValue (IN) Value to be written
212 Return: none
213 ******************************************************************************/
ostiChipWriteBit32(tiRoot_t * ptiRoot,U32 chipOffset,U32 chipValue)214 void ostiChipWriteBit32( tiRoot_t *ptiRoot, U32 chipOffset, U32 chipValue )
215 {
216 ag_card_info_t *pCardInfo;
217 pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
218 *(U32 *)(pCardInfo->pciMemVirtAddr + chipOffset) = chipValue;
219 }
220
221 /******************************************************************************
222 ostiChipReadBit32Ext()
223 Purpose:
224 Read 32-bit value from PCI address register
225 Parameters:
226 tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
227 busBaseNumber PCI BAR number
228 U32 chipOffset (IN) Offset to PCI configuration register
229 Return:
230 32 bit data
231 ******************************************************************************/
ostiChipReadBit32Ext(tiRoot_t * ptiRoot,U32 busBaseNumber,U32 chipOffset)232 U32 ostiChipReadBit32Ext( tiRoot_t *ptiRoot,
233 U32 busBaseNumber,
234 U32 chipOffset )
235 {
236 U32 data;
237 ag_card_info_t *pCardInfo;
238
239 pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
240 data = *(U32 *)((pCardInfo->pciMemVirtAddrSpc[busBaseNumber]) + chipOffset );
241 return data;
242 }
243
244 /******************************************************************************
245 ostiChipWriteBit32Ext()
246 Purpose:
247 Write 32-bit value to PCI address register
248 Parameters:
249 tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
250 busBaseNumber PCI BAR number
251 U32 chipOffset (IN) Offset to PCI configuration register
252 U32 chipValue (IN) Value to be written
253 Return: none
254 ******************************************************************************/
ostiChipWriteBit32Ext(tiRoot_t * ptiRoot,U32 busBaseNumber,U32 chipOffset,U32 aData)255 void ostiChipWriteBit32Ext( tiRoot_t *ptiRoot,
256 U32 busBaseNumber,
257 U32 chipOffset,
258 U32 aData )
259 {
260 ag_card_info_t *pCardInfo;
261 pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
262 *(U32 *)((pCardInfo->pciMemVirtAddrSpc[busBaseNumber]) + chipOffset ) = aData;
263 }
264
265 /******************************************************************************
266 ostiChipReadBit8()
267 Purpose:
268 Read 8-bit value from PCI address register
269 Parameters:
270 tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
271 U32 chipOffset (IN) Offset to PCI configuration register
272 Return:
273 8 bit data
274 ******************************************************************************/
ostiChipReadBit8(tiRoot_t * ptiRoot,U32 chipOffset)275 U08 ostiChipReadBit8( tiRoot_t *ptiRoot, U32 chipOffset )
276 {
277 ag_card_info_t *pCardInfo;
278 pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
279 return *(U08 *)( pCardInfo->pciMemVirtAddr + chipOffset );
280 }
281
282 /******************************************************************************
283 ostiChipWriteBit8()
284 Purpose:
285 Write 8-bit value to PCI address register
286 Parameters:
287 tiRoot_t *ptiRoot (IN) Pointer to tiRoot structure
288 U32 chipOffset (IN) Offset to PCI configuration register
289 U8 chipValue (IN) Value to be written
290 Return: none
291 ******************************************************************************/
ostiChipWriteBit8(tiRoot_t * ptiRoot,U32 chipOffset,U08 chipValue)292 void ostiChipWriteBit8( tiRoot_t *ptiRoot, U32 chipOffset, U08 chipValue )
293 {
294 ag_card_info_t *pCardInfo;
295 pCardInfo = TIROOT_TO_CARDINFO(ptiRoot);
296 *(U08 *)( pCardInfo->pciMemVirtAddr + chipOffset ) = chipValue;
297 }
298
299
ostiFlashReadBlock(tiRoot_t * ptiRoot,U32 offset,void * bufPtr,U32 nbytes)300 void ostiFlashReadBlock(tiRoot_t *ptiRoot,
301 U32 offset,
302 void *bufPtr,
303 U32 nbytes)
304 {
305 AGTIAPI_PRINTK( "ostiFlashReadBlock: No support for iscsi device\n" );
306 }
307
308 /******************************************************************************
309 ostiFreeMemory()
310 Purpose:
311 TD layer calls to free allocated dma memory
312 Parameters:
313 tiRoot_t *ptiRoot (IN) Pointer refers to the current root
314 void *osMemHandle (IN) Pointer to OS mem handle to be released
315 u32 allocLength (IN) Aloocated memory length in byte
316 Return:
317 tiSuccess - success
318 tiInvalidHandle - handle is invalid
319 ******************************************************************************/
ostiFreeMemory(tiRoot_t * ptiRoot,void * osMemHandle,U32 allocLength)320 osGLOBAL U32 ostiFreeMemory( tiRoot_t *ptiRoot,
321 void *osMemHandle,
322 U32 allocLength )
323 {
324 ag_card_info_t *pCardInfo = TIROOT_TO_CARDINFO( ptiRoot );
325 ag_dma_addr_t *pMem = (ag_dma_addr_t*)osMemHandle;
326 struct agtiapi_softc *pCard;
327 pCard = TIROOT_TO_CARD(ptiRoot);
328
329 if( !osMemHandle ) {
330 AGTIAPI_PRINTK( "ostiFreeMemory: NULL handle ERROR\n" );
331 return tiInvalidHandle;
332 }
333
334 AGTIAPI_PRINTK( "ostiFreeMemory: debug message %p ### \n",
335 (void*)pMem->dmaPhysAddr );
336
337 // mark as unused
338 pMem->memSize = 0;
339 pMem->dmaVirtAddr = NULL;
340 pMem->dmaPhysAddr = 0;
341
342 if (pCardInfo->topOfFreeDynamicMem == AGTIAPI_DYNAMIC_MAX) {
343 AGTIAPI_PRINTK( "ostiFreeMemory: too many free slots ERROR\n" );
344 return tiInvalidHandle;
345 }
346
347 mtx_lock(&pCard->memLock);
348 pCardInfo->freeDynamicMem[pCardInfo->topOfFreeDynamicMem++] = pMem;
349 mtx_unlock(&pCard->memLock);
350
351 return tiSuccess;
352 }
353
354
355 /******************************************************************************
356 ostiMakeParamString()
357 Purpose:
358 Utility function to simplify flow in ostiGetTransportParam(). Produces
359 a string handle constructed from ostiGetTransportParam() values:
360 key, subkey1, subkey2, subkey3, subkey4, subkey5, and valueName.
361 Parameters:
362 S08 *aKey (IN) Pointer to 1st level parameter string
363 S08 *aSubkey1 (IN) Pointer to 2nd level parameter string
364 S08 *aSubkey2 (IN) Pointer to 3rd level parameter string
365 S08 *aSubkey3 (IN) Pointer to 4th level parameter string
366 S08 *aSubkey4 (IN) Pointer to 5th level parameter string
367 S08 *aSubkey5 (IN) Pointer to 6th level parameter string
368 S08 *aValueName (IN) Pointer to name string of the value under keys
369 S08 *aFullKey (OUT) Pointer to returned key-value-handle buffer
370 U32 *apLenFullKey (OUT) String length in the key-value-handle buffer
371 Return:
372 tiSuccess - Success
373 tiError - Failed
374 Note:
375 If all input strings are NULL, tiError will return with zero in apLenFullKey
376 *****************************************************************************/
ostiMakeParamString(S08 * aKey,S08 * aSubkey1,S08 * aSubkey2,S08 * aSubkey3,S08 * aSubkey4,S08 * aSubkey5,S08 * aValueName,S08 * aFullKey,U32 * apLenFullKey)377 inline static U32 ostiMakeParamString( S08 *aKey,
378 S08 *aSubkey1,
379 S08 *aSubkey2,
380 S08 *aSubkey3,
381 S08 *aSubkey4,
382 S08 *aSubkey5,
383 S08 *aValueName,
384 S08 *aFullKey,
385 U32 *apLenFullKey )
386 {
387 // preliminary sanity checks
388 if( agNULL == aKey ) {
389 *apLenFullKey = 0;
390 printf( "ostiGetTransportParam called with no key. how odd.\n" );
391 return tiError;
392 }
393 if( agNULL == aValueName ) {
394 *apLenFullKey = 0;
395 printf( "ostiGetTransportParam called with no value-name. how odd.\n" );
396 return tiError;
397 }
398
399 strcpy( aFullKey, "DPMC_" ); // start at the beginning of the string
400 strcat( aFullKey, aKey );
401
402 int lIdx;
403 S08 *lStrIdx = agNULL;
404 for( lIdx = 1; lIdx <= 5; lIdx++ ) {
405 if( 1 == lIdx) lStrIdx = aSubkey1;
406 if( 2 == lIdx) lStrIdx = aSubkey2;
407 if( 3 == lIdx) lStrIdx = aSubkey3;
408 if( 4 == lIdx) lStrIdx = aSubkey4;
409 if( 5 == lIdx) lStrIdx = aSubkey5;
410 if( agNULL == lStrIdx ) break; // no more key information
411 // append key information
412 strcat( aFullKey, "_" );
413 strcat( aFullKey, lStrIdx );
414 }
415
416 // only the value name is left to append
417 strcat( aFullKey, "_" );
418 strcat( aFullKey, aValueName );
419
420 *apLenFullKey = strlen( aFullKey ); // 58 is max len seen; June 11, 2012
421 // printf( "ostiMakeParamString: x%d out-str:%s\n", // debug print
422 // *apLenFullKey, aFullKey );
423
424 return tiSuccess; // ship it chief
425 }
426
427
428 /******************************************************************************
429 ostiGetTransportParam()
430 Purpose:
431 Call back function from lower layer to get parameters.
432 Parameters:
433 tiRoot_t *ptiRoot (IN) Pointer to driver root data structure
434 S08 *key (IN) Pointer to 1st level parameter
435 S08 *subkey1 (IN) Pointer to 2nd level parameter
436 S08 *subkey2 (IN) Pointer to 3rd level parameter
437 S08 *subkey3 (IN) Pointer to 4th level parameter
438 S08 *subkey4 (IN) Pointer to 5th level parameter
439 S08 *subkey5 (IN) Pointer to 6th level parameter
440 S08 *valueName (IN) Pointer to name of the value under keys
441 S08 *buffer (OUT) Pointer to returned information buffer
442 U32 bufferLen (OUT) Buffer length
443 U32 *lenReceived (OUT) String length in the buffer
444 Return:
445 tiSuccess - Success
446 Other - Failed
447 Note:
448 The scheme of searching adjustable parameter tree is the following:
449 key
450 - subkey1
451 - subkey2
452 - subkey3
453 - subkey4
454 - subkey5
455 - value
456 If no match in any case, tiError will return with zero length.
457
458 Where there is no indication of max key and subkey length,
459 an upper limit guess of 200 is used.
460 Perhaps a prudent revision would be to add some argument(s) to be
461 able to manage/check these "key" string lengths.
462 This function does no checking of buffer being a valid pointer.
463 *****************************************************************************/
ostiGetTransportParam(tiRoot_t * ptiRoot,S08 * key,S08 * subkey1,S08 * subkey2,S08 * subkey3,S08 * subkey4,S08 * subkey5,S08 * valueName,S08 * buffer,U32 bufferLen,U32 * lenReceived)464 U32 ostiGetTransportParam( tiRoot_t *ptiRoot,
465 S08 *key,
466 S08 *subkey1,
467 S08 *subkey2,
468 S08 *subkey3,
469 S08 *subkey4,
470 S08 *subkey5,
471 S08 *valueName,
472 S08 *buffer,
473 U32 bufferLen,
474 U32 *lenReceived )
475 {
476 S08 lFullKey[200];
477 U32 lLenFullKey = 0;
478 *lenReceived = 0;
479
480 if( bufferLen > 1 )
481 strcpy( buffer, "" );
482 else {
483 printf( "ostiGetTransportParam: buffer too small at only %d",
484 bufferLen );
485 return tiError; // not a reasonable buffer to work with
486 }
487 ostiMakeParamString( key, subkey1, subkey2, subkey3, subkey4, subkey5,
488 valueName, lFullKey, &lLenFullKey );
489 if( lLenFullKey ) // clean ParamString extraction
490 TUNABLE_STR_FETCH( lFullKey, buffer, bufferLen );
491 else
492 return tiError; // not working out, bail now
493
494 *lenReceived = strlen( buffer );
495
496 //if( *lenReceived ) // handy debug print
497 // printf( "ostiGetTransportParam: sz%d val:%s hdl-str:%s\n",
498 // *lenReceived, buffer, lFullKey );
499
500 return tiSuccess; // ship it chief
501 }
502
503
504 /******************************************************************************
505 ostiIOCTLClearSignal()
506
507 Purpose:
508 Function to clear or reset semaphore during ioctl
509 Parameters:
510 tiRoot_t *ptiRoot (IN) Pointer to the current HBA
511 void **agParam1 (IN_OUT) Pointer to context to be passed
512 void **agParam2 (IN_OUT) Pointer to context to be passed
513 void **agParam (IN_OUT) Pointer to context to be passed
514 Return:
515 Note:
516 TBD, need more work for card based semaphore. Also needs to
517 consider the calling sequence.
518 ******************************************************************************/
519 osGLOBAL void
ostiIOCTLClearSignal(tiRoot_t * ptiRoot,void ** agParam1,void ** agParam2,void ** agParam3)520 ostiIOCTLClearSignal(tiRoot_t *ptiRoot,
521 void **agParam1,
522 void **agParam2,
523 void **agParam3)
524 {
525 }
526
527
528 /******************************************************************************
529 ostiIOCTLSetSignal() ### function currently stubbed out
530 Purpose:
531 Function to set semaphore during ioctl
532 Parameters:
533 tiRoot_t *ptiRoot (IN) Pointer to the current HBA
534 void **agParam1 (IN_OUT) Pointer to context to be passed
535 void **agParam2 (IN_OUT) Pointer to context to be passed
536 void **agParam (IN_OUT) Pointer to context to be passed
537 Return:
538 Note:
539 ******************************************************************************/
540 osGLOBAL void
ostiIOCTLSetSignal(tiRoot_t * ptiRoot,void * agParam1,void * agParam2,void * agParam3)541 ostiIOCTLSetSignal(tiRoot_t *ptiRoot,
542 void *agParam1,
543 void *agParam2,
544 void *agParam3)
545 {
546 struct agtiapi_softc *pCard;
547 pCard = TIROOT_TO_CARD(ptiRoot);
548 if (pCard->down_count != pCard->up_count)
549 {
550 pCard->up_count++;
551 sema_post (pCard->pIoctlSem);
552 }
553 }
554
555 osGLOBAL void
ostiIOCTLComplete(tiRoot_t * ptiRoot,void * agParam1,void * agParam2,void * agParam3)556 ostiIOCTLComplete(tiRoot_t *ptiRoot,
557 void *agParam1,
558 void *agParam2,
559 void *agParam3)
560 {
561 struct agtiapi_softc *pCard;
562 pCard = TIROOT_TO_CARD(ptiRoot);
563 if (pCard->down_count != pCard->up_count)
564 {
565 pCard->up_count++;
566 sema_post (pCard->pIoctlSem);
567 }
568 }
569
570 /******************************************************************************
571 ostiPortEvent()
572 Purpose:
573 Call back function to inform OS the events of port state change.
574 Parameters:
575 tiRoot_t *ptiRoot(IN) Pointer to driver root data structure
576 tiPortEvent_t eventType (IN) Type of port event:
577 tiPortPanic
578 tiPortResetComplete
579 tiPortNameServerDown
580 tiPortLinkDown
581 tiPortLinkUp
582 tiPortStarted
583 tiPortStopped
584 tiPortShutdown
585 tiPortInitComplete
586 void *pParm(IN) Pointer to event specific structure
587 Return:
588 None
589 ******************************************************************************/
590 void
ostiPortEvent(tiRoot_t * ptiRoot,tiPortEvent_t eventType,U32 status,void * pParm)591 ostiPortEvent(tiRoot_t *ptiRoot,
592 tiPortEvent_t eventType,
593 U32 status,
594 void *pParm)
595 {
596 struct agtiapi_softc *pCard;
597 ag_portal_data_t *pPortalData;
598
599 AGTIAPI_PRINTK("ostiPortEvent: start eventType 0x%x\n", eventType);
600
601 pCard = TIROOT_TO_CARD(ptiRoot);
602
603 switch (eventType)
604 {
605 case tiPortStarted:
606 pCard->flags |= AGTIAPI_CB_DONE;
607 pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
608 PORTAL_STATUS(pPortalData) |= AGTIAPI_PORT_START;
609 AGTIAPI_PRINTK("PortStarted - portal %p, status %x\n",
610 pPortalData, PORTAL_STATUS(pPortalData));
611 break;
612 case tiPortLinkDown:
613 pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
614 PORTAL_STATUS(pPortalData) &= ~AGTIAPI_PORT_LINK_UP;
615 AGTIAPI_PRINTK("PortLinkDown - portal %p\n", pPortalData);
616 break;
617 case tiPortLinkUp:
618 pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
619 PORTAL_STATUS(pPortalData) |= AGTIAPI_PORT_LINK_UP;
620 AGTIAPI_PRINTK("PortLinkUp - portal %p\n", pPortalData);
621 #ifdef INITIATOR_DRIVER
622 #ifndef HOTPLUG_SUPPORT
623 if (!(pCard->flags & AGTIAPI_INIT_TIME))
624 #endif
625 // agtiapi_StartIO(pCard);
626 #endif
627 break;
628 case tiPortDiscoveryReady:
629 pCard->flags |= AGTIAPI_CB_DONE;
630 pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
631 PORTAL_STATUS(pPortalData) |= AGTIAPI_PORT_DISC_READY;
632 AGTIAPI_PRINTK("PortDiscoveryReady - portal %p, status 0x%x\n",
633 pPortalData, PORTAL_STATUS(pPortalData));
634 #ifdef INITIATOR_DRIVER
635 #ifndef HOTPLUG_SUPPORT
636 if (!(pCard->flags & AGTIAPI_INIT_TIME))
637 #endif
638 tiINIDiscoverTargets(&pCard->tiRoot,
639 &pPortalData->portalInfo.tiPortalContext,
640 FORCE_PERSISTENT_ASSIGN_MASK);
641 #endif
642 break;
643 case tiPortNameServerDown:
644 AGTIAPI_PRINTK("PortNameSeverDown\n");
645 pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
646 PORTAL_STATUS(pPortalData) &= ~AGTIAPI_NAME_SERVER_UP;
647 break;
648 case tiPortPanic:
649 AGTIAPI_PRINTK("PortPanic\n");
650 AGTIAPI_PRINTK( "## PortEvent\n" );
651 pCard->flags |= AGTIAPI_PORT_PANIC;
652 break;
653 case tiPortResetComplete:
654 AGTIAPI_PRINTK("PortResetComplete\n");
655 pCard->flags |= AGTIAPI_CB_DONE;
656 if (status == tiSuccess)
657 pCard->flags |= AGTIAPI_RESET_SUCCESS;
658 break;
659 case tiPortShutdown:
660 AGTIAPI_PRINTK("PortShutdown\n");
661 pCard->flags |= AGTIAPI_CB_DONE;
662 pCard->flags |= AGTIAPI_PORT_SHUTDOWN;
663 break;
664 case tiPortStopped:
665 pCard->flags |= AGTIAPI_CB_DONE;
666 pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(pParm);
667 PORTAL_STATUS(pPortalData) |= AGTIAPI_PORT_STOPPED;
668 AGTIAPI_PRINTK("PortStopped - portal %p\n", pPortalData);
669 break;
670 case tiEncryptOperation:
671 break;
672 case tiModePageOperation:
673 break;
674 default:
675 AGTIAPI_PRINTK("PortEvent - %d (Unknown)\n", eventType);
676 break;
677 }
678 return;
679 }
680
681
682 /******************************************************************************
683 ostiStallThread()
684 Purpose:
685 Stall the thread (busy wait) for a number of microseconds.
686 Parameters:
687 tiRoot_t *ptiRoot (IN) Pointer to the tiRoot data structure
688 U32 microseconds (IN) Micro-seconds to be hold
689 Returns: none
690 ******************************************************************************/
ostiStallThread(tiRoot_t * ptiRoot,U32 microseconds)691 void ostiStallThread( tiRoot_t *ptiRoot, U32 microseconds )
692 {
693 DELAY( microseconds );
694 }
695
696
697 /******************************************************************************
698 ostiTimeStamp() ### stubbed out for now
699 Purpose:
700 Time stamp
701 Parameters:
702 tiRoot_t *ptiRoot (IN) Pointer to the tiRoot data structure
703 Returns:
704 Time stamp in milisecond
705 ******************************************************************************/
706 U32
ostiTimeStamp(tiRoot_t * ptiRoot)707 ostiTimeStamp(tiRoot_t *ptiRoot)
708 {
709 return 0;
710 }
711
712 // meant as stubbed out 64 bit version.
ostiTimeStamp64(tiRoot_t * ptiRoot)713 U64 ostiTimeStamp64( tiRoot_t *ptiRoot )
714 {
715 U64 retVal;
716 retVal = ostiTimeStamp( ptiRoot );
717 return retVal;
718 }
719
720 /******************************************************************************
721 ostiCacheFlush() ### stubbed out for now
722 ostiCacheInvalidate()
723 ostiCachePreFlush()
724
725 Purpose:
726 Cache-coherency APIs
727 Parameters:
728
729 Returns:
730
731 Note:
732 These 3 functions are to support new cache coherency applications.
733 Currently the APIs are implemented in FC for PPC platform. The
734 define CACHED_DMA enable for dma_cache_sync function call. However
735 this define is restricted for certain version of linux, such as
736 Linux 2.6.x and above, and certain platform such as PPC.
737
738 DO NOT define the CACHED_DMA if the cache coherency is not required
739 or the environment does not match.
740 ******************************************************************************/
ostiCacheFlush(tiRoot_t * ptiRoot,void * osMemHandle,void * virtPtr,bit32 length)741 osGLOBAL void ostiCacheFlush(
742 tiRoot_t *ptiRoot,
743 void *osMemHandle,
744 void *virtPtr,
745 bit32 length
746 )
747 {
748 }
749
ostiCacheInvalidate(tiRoot_t * ptiRoot,void * osMemHandle,void * virtPtr,bit32 length)750 osGLOBAL void ostiCacheInvalidate(
751 tiRoot_t *ptiRoot,
752 void *osMemHandle,
753 void *virtPtr,
754 bit32 length
755 )
756 {
757 }
758
ostiCachePreFlush(tiRoot_t * tiRoot,void * osMemHandle,void * virtPtr,bit32 length)759 osGLOBAL void ostiCachePreFlush(
760 tiRoot_t *tiRoot,
761 void *osMemHandle,
762 void *virtPtr,
763 bit32 length
764 )
765 {
766 }
767
768
769 /*
770 added for SAS/SATA
771 this is called by ossaInterrruptEnable
772 */
ostiInterruptEnable(tiRoot_t * ptiRoot,bit32 channelNum)773 GLOBAL void ostiInterruptEnable( tiRoot_t *ptiRoot, bit32 channelNum )
774 {
775 // yep, really nothing.
776 }
777
778 /*
779 this is called by ossaInterrruptDisable
780 */
ostiInterruptDisable(tiRoot_t * ptiRoot,bit32 channelNum)781 GLOBAL void ostiInterruptDisable( tiRoot_t *ptiRoot, bit32 channelNum )
782 {
783 // yep, really nothing.
784 }
785
786