开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
mf.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：29k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

mf.c：源码内容
  1. /*
  2.   * mf.c
  3.   * Copyright (C) 2001 Troy D. Armstrong  IBM Corporation
  4.   *
  5.   * This modules exists as an interface between a Linux secondary partition
  6.   * running on an iSeries and the primary partition's Virtual Service
  7.   * Processor (VSP) object.  The VSP has final authority over powering on/off
  8.   * all partitions in the iSeries.  It also provides miscellaneous low-level
  9.   * machine facility type operations.
  10.   *
  11.   * 
  12.   * This program is free software; you can redistribute it and/or modify
  13.   * it under the terms of the GNU General Public License as published by
  14.   * the Free Software Foundation; either version 2 of the License, or
  15.   * (at your option) any later version.
  16.   * 
  17.   * This program is distributed in the hope that it will be useful,
  18.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.   * GNU General Public License for more details.
  21.   * 
  22.   * You should have received a copy of the GNU General Public License
  23.   * along with this program; if not, write to the Free Software
  24.   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  25.   */
  27. #include <asm/iSeries/mf.h>
  28. #include <linux/types.h>
  29. #include <linux/errno.h>
  30. #include <linux/kernel.h>
  31. #include <linux/init.h>
  32. #include <linux/mm.h>
  33. #include <asm/iSeries/HvLpConfig.h>
  34. #include <linux/slab.h>
  35. #include <linux/delay.h>
  36. #include <asm/nvram.h>
  37. #include <asm/time.h>
  38. #include <asm/iSeries/ItSpCommArea.h>
  39. #include <asm/iSeries/mf_proc.h>
  40. #include <asm/iSeries/iSeries_proc.h>
  41. #include <asm/uaccess.h>
  42. #include <linux/pci.h>
  44. extern struct pci_dev * iSeries_vio_dev;
  46. /*
  47.  * This is the structure layout for the Machine Facilites LPAR event
  48.  * flows.
  49.  */
  50. struct VspCmdData;
  51. struct CeMsgData;
  52. union SafeCast
  53. {
  54. u64 ptrAsU64;
  55. void *ptr;
  56. };
  59. typedef void (*CeMsgCompleteHandler)( void *token, struct CeMsgData *vspCmdRsp );
  61. struct CeMsgCompleteData
  62. {
  63. CeMsgCompleteHandler xHdlr;
  64. void *xToken;
  65. };
  67. struct VspRspData
  68. {
  69. struct semaphore *xSemaphore;
  70. struct VspCmdData *xResponse;
  71. };
  73. struct IoMFLpEvent
  74. {
  75. struct HvLpEvent xHvLpEvent;
  77. u16 xSubtypeRc;
  78. u16 xRsvd1;
  79. u32 xRsvd2;
  81. union
  82. {
  84. struct AllocData
  85. {
  86. u16 xSize;
  87. u16 xType;
  88. u32 xCount;
  89. u16 xRsvd3;
  90. u8 xRsvd4;
  91. HvLpIndex xTargetLp;
  92. } xAllocData;
  94. struct CeMsgData
  95. {
  96. u8 xCEMsg[12];
  97. char xReserved[4];
  98. struct CeMsgCompleteData *xToken;
  99. } xCEMsgData;
  101. struct VspCmdData
  102. {
  103. union SafeCast xTokenUnion;
  104. u16 xCmd;
  105. HvLpIndex xLpIndex;
  106. u8 xRc;
  107. u32 xReserved1;
  109. union VspCmdSubData
  110. {
  111. struct
  112. {
  113. u64 xState;
  114. } xGetStateOut;
  116. struct
  117. {
  118. u64 xIplType;
  119. } xGetIplTypeOut, xFunction02SelectIplTypeIn;
  121. struct
  122. {
  123. u64 xIplMode;
  124. } xGetIplModeOut, xFunction02SelectIplModeIn;
  126. struct
  127. {
  128. u64 xPage[4];
  129. } xGetSrcHistoryIn;
  131. struct
  132. {
  133. u64 xFlag;
  134. } xGetAutoIplWhenPrimaryIplsOut,
  135. xSetAutoIplWhenPrimaryIplsIn,
  136. xWhiteButtonPowerOffIn,
  137. xFunction08FastPowerOffIn,
  138. xIsSpcnRackPowerIncompleteOut;
  140. struct
  141. {
  142. u64 xToken;
  143. u64 xAddressType;
  144. u64 xSide;
  145. u32 xTransferLength;
  146. u32 xOffset;
  147. } xSetKernelImageIn,
  148. xGetKernelImageIn,
  149. xSetKernelCmdLineIn,
  150. xGetKernelCmdLineIn;
  152. struct
  153. {
  154. u32 xTransferLength;
  155. } xGetKernelImageOut,xGetKernelCmdLineOut;
  158. u8 xReserved2[80];
  160. } xSubData;
  161. } xVspCmd;
  162. } xUnion;
  163. };
  166. /*
  167.  * All outgoing event traffic is kept on a FIFO queue.  The first
  168.  * pointer points to the one that is outstanding, and all new
  169.  * requests get stuck on the end.  Also, we keep a certain number of
  170.  * preallocated stack elements so that we can operate very early in
  171.  * the boot up sequence (before kmalloc is ready).
  172.  */
  173. struct StackElement
  174. {
  175. struct StackElement * next;
  176. struct IoMFLpEvent event;
  177. MFCompleteHandler hdlr;
  178. char dmaData[72];
  179. unsigned dmaDataLength;
  180. unsigned remoteAddress;
  181. };
  182. static spinlock_t spinlock;
  183. static struct StackElement * head = NULL;
  184. static struct StackElement * tail = NULL;
  185. static struct StackElement * avail = NULL;
  186. static struct StackElement prealloc[16];
  188. /*
  189.  * Put a stack element onto the available queue, so it can get reused.
  190.  * Attention! You must have the spinlock before calling!
  191.  */
  192. void free( struct StackElement * element )
  193. {
  194. if ( element != NULL )
  195. {
  196. element->next = avail;
  197. avail = element;
  198. }
  199. }
  201. /*
  202.  * Enqueue the outbound event onto the stack.  If the queue was
  203.  * empty to begin with, we must also issue it via the Hypervisor
  204.  * interface.  There is a section of code below that will touch
  205.  * the first stack pointer without the protection of the spinlock.
  206.  * This is OK, because we know that nobody else will be modifying
  207.  * the first pointer when we do this.
  208.  */
  209. static int signalEvent( struct StackElement * newElement )
  210. {
  211. int rc = 0;
  212. unsigned long flags;
  213. int go = 1;
  214. struct StackElement * element;
  215. HvLpEvent_Rc hvRc;
  217. /* enqueue the event */
  218. if ( newElement != NULL )
  219. {
  220. spin_lock_irqsave( &spinlock, flags );
  221. if ( head == NULL )
  222. head = newElement;
  223. else {
  224. go = 0;
  225. tail->next = newElement;
  226. }
  227. newElement->next = NULL;
  228. tail = newElement;
  229. spin_unlock_irqrestore( &spinlock, flags );
  230. }
  232. /* send the event */
  233. while ( go )
  234. {
  235. go = 0;
  237. /* any DMA data to send beforehand? */
  238. if ( head->dmaDataLength > 0 )
  239. HvCallEvent_dmaToSp( head->dmaData, head->remoteAddress, head->dmaDataLength, HvLpDma_Direction_LocalToRemote );
  241. hvRc = HvCallEvent_signalLpEvent(&head->event.xHvLpEvent);
  242. if ( hvRc != HvLpEvent_Rc_Good )
  243. {
  244. printk( KERN_ERR "mf.c: HvCallEvent_signalLpEvent() failed with %dn", (int)hvRc );
  246. spin_lock_irqsave( &spinlock, flags );
  247. element = head;
  248. head = head->next;
  249. if ( head != NULL )
  250. go = 1;
  251. spin_unlock_irqrestore( &spinlock, flags );
  253. if ( element == newElement )
  254. rc = -EIO;
  255. else {
  256. if ( element->hdlr != NULL )
  257. {
  258. union SafeCast mySafeCast;
  259. mySafeCast.ptrAsU64 = element->event.xHvLpEvent.xCorrelationToken;
  260. (*element->hdlr)( mySafeCast.ptr, -EIO );
  261. }
  262. }
  264. spin_lock_irqsave( &spinlock, flags );
  265. free( element );
  266. spin_unlock_irqrestore( &spinlock, flags );
  267. }
  268. }
  270. return rc;
  271. }
  273. /*
  274.  * Allocate a new StackElement structure, and initialize it.
  275.  */
  276. static struct StackElement * newStackElement( void )
  277. {
  278. struct StackElement * newElement = NULL;
  279. HvLpIndex primaryLp = HvLpConfig_getPrimaryLpIndex();
  280. unsigned long flags;
  282. if ( newElement == NULL )
  283. {
  284. spin_lock_irqsave( &spinlock, flags );
  285. if ( avail != NULL )
  286. {
  287. newElement = avail;
  288. avail = avail->next;
  289. }
  290. spin_unlock_irqrestore( &spinlock, flags );
  291. }
  293. if ( newElement == NULL )
  294. newElement = kmalloc(sizeof(struct StackElement),GFP_ATOMIC);
  296. if ( newElement == NULL )
  297. {
  298. printk( KERN_ERR "mf.c: unable to kmalloc %ld bytesn", sizeof(struct StackElement) );
  299. return NULL;
  300. }
  302. memset( newElement, 0, sizeof(struct StackElement) );
  303. newElement->event.xHvLpEvent.xFlags.xValid = 1;
  304. newElement->event.xHvLpEvent.xFlags.xAckType = HvLpEvent_AckType_ImmediateAck;
  305. newElement->event.xHvLpEvent.xFlags.xAckInd = HvLpEvent_AckInd_DoAck;
  306. newElement->event.xHvLpEvent.xFlags.xFunction = HvLpEvent_Function_Int;
  307. newElement->event.xHvLpEvent.xType = HvLpEvent_Type_MachineFac;
  308. newElement->event.xHvLpEvent.xSourceLp = HvLpConfig_getLpIndex();
  309. newElement->event.xHvLpEvent.xTargetLp = primaryLp;
  310. newElement->event.xHvLpEvent.xSizeMinus1 = sizeof(newElement->event)-1;
  311. newElement->event.xHvLpEvent.xRc = HvLpEvent_Rc_Good;
  312. newElement->event.xHvLpEvent.xSourceInstanceId = HvCallEvent_getSourceLpInstanceId(primaryLp,HvLpEvent_Type_MachineFac);
  313. newElement->event.xHvLpEvent.xTargetInstanceId = HvCallEvent_getTargetLpInstanceId(primaryLp,HvLpEvent_Type_MachineFac);
  315. return newElement;
  316. }
  318. static int signalVspInstruction( struct VspCmdData *vspCmd )
  319. {
  320. struct StackElement * newElement = newStackElement();
  321. int rc = 0;
  322. struct VspRspData response;
  323. DECLARE_MUTEX_LOCKED(Semaphore);
  324. response.xSemaphore = &Semaphore;
  325. response.xResponse = vspCmd;
  327. if ( newElement == NULL )
  328. rc = -ENOMEM;
  329. else {
  330. newElement->event.xHvLpEvent.xSubtype = 6;
  331. newElement->event.xHvLpEvent.x.xSubtypeData = ('M'<<24)+('F'<<16)+('V'<<8)+('I'<<0);
  332. newElement->event.xUnion.xVspCmd.xTokenUnion.ptr = &response;
  333. newElement->event.xUnion.xVspCmd.xCmd = vspCmd->xCmd;
  334. newElement->event.xUnion.xVspCmd.xLpIndex = HvLpConfig_getLpIndex();
  335. newElement->event.xUnion.xVspCmd.xRc = 0xFF;
  336. newElement->event.xUnion.xVspCmd.xReserved1 = 0;
  337. memcpy(&(newElement->event.xUnion.xVspCmd.xSubData),&(vspCmd->xSubData), sizeof(vspCmd->xSubData));
  338. mb();
  340. rc = signalEvent(newElement);
  341. }
  343. if (rc == 0)
  344. {
  345. down(&Semaphore);
  346. }
  348. return rc;
  349. }
  352. /*
  353.  * Send a 12-byte CE message to the primary partition VSP object
  354.  */
  355. static int signalCEMsg( char * ceMsg, void * token )
  356. {
  357. struct StackElement * newElement = newStackElement();
  358. int rc = 0;
  360. if ( newElement == NULL )
  361. rc = -ENOMEM;
  362. else {
  363. newElement->event.xHvLpEvent.xSubtype = 0;
  364. newElement->event.xHvLpEvent.x.xSubtypeData = ('M'<<24)+('F'<<16)+('C'<<8)+('E'<<0);
  365. memcpy( newElement->event.xUnion.xCEMsgData.xCEMsg, ceMsg, 12 );
  366. newElement->event.xUnion.xCEMsgData.xToken = token;
  367. rc = signalEvent(newElement);
  368. }
  370. return rc;
  371. }
  373. /*
  374.  * Send a 12-byte CE message and DMA data to the primary partition VSP object
  375.  */
  376. static int dmaAndSignalCEMsg( char * ceMsg, void * token, void * dmaData, unsigned dmaDataLength, unsigned remoteAddress )
  377. {
  378. struct StackElement * newElement = newStackElement();
  379. int rc = 0;
  381. if ( newElement == NULL )
  382. rc = -ENOMEM;
  383. else {
  384. newElement->event.xHvLpEvent.xSubtype = 0;
  385. newElement->event.xHvLpEvent.x.xSubtypeData = ('M'<<24)+('F'<<16)+('C'<<8)+('E'<<0);
  386. memcpy( newElement->event.xUnion.xCEMsgData.xCEMsg, ceMsg, 12 );
  387. newElement->event.xUnion.xCEMsgData.xToken = token;
  388. memcpy( newElement->dmaData, dmaData, dmaDataLength );
  389. newElement->dmaDataLength = dmaDataLength;
  390. newElement->remoteAddress = remoteAddress;
  391. rc = signalEvent(newElement);
  392. }
  394. return rc;
  395. }
  397. /*
  398.  * Initiate a nice (hopefully) shutdown of Linux.  We simply are
  399.  * going to try and send the init process a SIGINT signal.  If
  400.  * this fails (why?), we'll simply force it off in a not-so-nice
  401.  * manner.
  402.  */
  403. static int shutdown( void )
  404. {
  405. int rc = kill_proc(1,SIGINT,1);
  407. if ( rc )
  408. {
  409. printk( KERN_ALERT "mf.c: SIGINT to init failed (%d), hard shutdown commencingn", rc );
  410. mf_powerOff();
  411. }
  412. else
  413. printk( KERN_INFO "mf.c: init has been successfully notified to proceed with shutdownn" );
  415. return rc;
  416. }
  418. /*
  419.  * The primary partition VSP object is sending us a new
  420.  * event flow.  Handle it...
  421.  */
  422. static void intReceived( struct IoMFLpEvent * event )
  423. {
  424. int freeIt = 0;
  425. struct StackElement * two = NULL;
  426. /* ack the interrupt */
  427. event->xHvLpEvent.xRc = HvLpEvent_Rc_Good;
  428. HvCallEvent_ackLpEvent( &event->xHvLpEvent );
  430.     /* process interrupt */
  431. switch( event->xHvLpEvent.xSubtype )
  432. {
  433. case 0: /* CE message */
  434. switch( event->xUnion.xCEMsgData.xCEMsg[3] )
  435. {
  436. case 0x5B: /* power control notification */
  437. if ( (event->xUnion.xCEMsgData.xCEMsg[5]&0x20) != 0 )
  438. {
  439. printk( KERN_INFO "mf.c: Commencing partition shutdownn" );
  440. if ( shutdown() == 0 )
  441. signalCEMsg( "x00x00x00xDBx00x00x00x00x00x00x00x00", NULL );
  442. }
  443. break;
  444. case 0xC0: /* get time */
  445. {
  446. if ( (head != NULL) && ( head->event.xUnion.xCEMsgData.xCEMsg[3] == 0x40 ) )
  447. {
  448. freeIt = 1;
  449. if ( head->event.xUnion.xCEMsgData.xToken != 0 )
  450. {
  451. CeMsgCompleteHandler xHdlr = head->event.xUnion.xCEMsgData.xToken->xHdlr;
  452. void * token = head->event.xUnion.xCEMsgData.xToken->xToken;
  454. if (xHdlr != NULL)
  455. (*xHdlr)( token, &(event->xUnion.xCEMsgData) );
  456. }
  457. }
  458. }
  459. break;
  460. }
  462. /* remove from queue */
  463. if ( freeIt == 1 )
  464. {
  465. unsigned long flags;
  466. spin_lock_irqsave( &spinlock, flags );
  467. if ( head != NULL )
  468. {
  469. struct StackElement *oldHead = head;
  470. head = head->next;
  471. two = head;
  472. free( oldHead );
  473. }
  474. spin_unlock_irqrestore( &spinlock, flags );
  475. }
  477. /* send next waiting event */
  478. if ( two != NULL )
  479. signalEvent( NULL );
  480. break;
  481. case 1: /* IT sys shutdown */
  482. printk( KERN_INFO "mf.c: Commencing system shutdownn" );
  483. shutdown();
  484. break;
  485. }
  486. }
  488. /*
  489.  * The primary partition VSP object is acknowledging the receipt
  490.  * of a flow we sent to them.  If there are other flows queued
  491.  * up, we must send another one now...
  492.  */
  493. static void ackReceived( struct IoMFLpEvent * event )
  494. {
  495. unsigned long flags;
  496. struct StackElement * two = NULL;
  497. unsigned long freeIt = 0;
  499.     /* handle current event */
  500. if ( head != NULL )
  501. {
  502. switch( event->xHvLpEvent.xSubtype )
  503. {
  504. case 0:     /* CE msg */
  505. if ( event->xUnion.xCEMsgData.xCEMsg[3] == 0x40 )
  506. {
  507. if ( event->xUnion.xCEMsgData.xCEMsg[2] != 0 )
  508. {
  509. freeIt = 1;
  510. if ( head->event.xUnion.xCEMsgData.xToken != 0 )
  511. {
  512. CeMsgCompleteHandler xHdlr = head->event.xUnion.xCEMsgData.xToken->xHdlr;
  513. void * token = head->event.xUnion.xCEMsgData.xToken->xToken;
  515. if (xHdlr != NULL)
  516. (*xHdlr)( token, &(event->xUnion.xCEMsgData) );
  517. }
  518. }
  519. } else {
  520. freeIt = 1;
  521. }
  522. break;
  523. case 4: /* allocate */
  524. case 5: /* deallocate */
  525. if ( head->hdlr != NULL )
  526. {
  527. union SafeCast mySafeCast;
  528. mySafeCast.ptrAsU64 = event->xHvLpEvent.xCorrelationToken;
  529. (*head->hdlr)( mySafeCast.ptr, event->xUnion.xAllocData.xCount );
  530. }
  531. freeIt = 1;
  532. break;
  533. case 6:
  534. {
  535. struct VspRspData *rsp = (struct VspRspData *)event->xUnion.xVspCmd.xTokenUnion.ptr;
  537. if (rsp != NULL)
  538. {
  539. if (rsp->xResponse != NULL)
  540. memcpy(rsp->xResponse, &(event->xUnion.xVspCmd), sizeof(event->xUnion.xVspCmd));
  541. if (rsp->xSemaphore != NULL)
  542. up(rsp->xSemaphore);
  543. } else {
  544. printk( KERN_ERR "mf.c: no rspn");
  545. }
  546. freeIt = 1;
  547. }
  548. break;
  549. }
  550. }
  551. else
  552. printk( KERN_ERR "mf.c: stack empty for receiving ackn" );
  554.     /* remove from queue */
  555. spin_lock_irqsave( &spinlock, flags );
  556. if (( head != NULL ) && ( freeIt == 1 ))
  557. {
  558. struct StackElement *oldHead = head;
  559. head = head->next;
  560. two = head;
  561. free( oldHead );
  562. } 
  563. spin_unlock_irqrestore( &spinlock, flags );
  565.     /* send next waiting event */
  566. if ( two != NULL )
  567. signalEvent( NULL );
  568. }
  570. /*
  571.  * This is the generic event handler we are registering with
  572.  * the Hypervisor.  Ensure the flows are for us, and then
  573.  * parse it enough to know if it is an interrupt or an
  574.  * acknowledge.
  575.  */
  576. static void hvHandler( struct HvLpEvent * event, struct pt_regs * regs )
  577. {
  578. if ( (event != NULL) && (event->xType == HvLpEvent_Type_MachineFac) )
  579. {
  580. switch( event->xFlags.xFunction )
  581. {
  582. case HvLpEvent_Function_Ack:
  583. ackReceived( (struct IoMFLpEvent *)event );
  584. break;
  585. case HvLpEvent_Function_Int:
  586. intReceived( (struct IoMFLpEvent *)event );
  587. break;
  588. default:
  589. printk( KERN_ERR "mf.c: non ack/int event receivedn" );
  590. break;
  591. }
  592. }
  593. else
  594. printk( KERN_ERR "mf.c: alien event receivedn" );
  595. }
  597. /*
  598.  * Global kernel interface to allocate and seed events into the
  599.  * Hypervisor.
  600.  */
  601. void mf_allocateLpEvents( HvLpIndex targetLp,
  602.   HvLpEvent_Type type,
  603.   unsigned size,
  604.   unsigned count,
  605.   MFCompleteHandler hdlr,
  606.   void * userToken )
  607. {
  608. struct StackElement * newElement = newStackElement();
  609. int rc = 0;
  611. if ( newElement == NULL )
  612. rc = -ENOMEM;
  613. else {
  614. union SafeCast mine;
  615. mine.ptr = userToken;
  616. newElement->event.xHvLpEvent.xSubtype = 4;
  617. newElement->event.xHvLpEvent.xCorrelationToken = mine.ptrAsU64;
  618. newElement->event.xHvLpEvent.x.xSubtypeData = ('M'<<24)+('F'<<16)+('M'<<8)+('A'<<0);
  619. newElement->event.xUnion.xAllocData.xTargetLp = targetLp;
  620. newElement->event.xUnion.xAllocData.xType = type;
  621. newElement->event.xUnion.xAllocData.xSize = size;
  622. newElement->event.xUnion.xAllocData.xCount = count;
  623. newElement->hdlr = hdlr;
  624. rc = signalEvent(newElement);
  625. }
  627. if ( (rc != 0) && (hdlr != NULL) )
  628. (*hdlr)( userToken, rc );
  629. }
  631. /*
  632.  * Global kernel interface to unseed and deallocate events already in
  633.  * Hypervisor.
  634.  */
  635. void mf_deallocateLpEvents( HvLpIndex targetLp,
  636.     HvLpEvent_Type type,
  637.     unsigned count,
  638.     MFCompleteHandler hdlr,
  639.     void * userToken )
  640. {
  641. struct StackElement * newElement = newStackElement();
  642. int rc = 0;
  644. if ( newElement == NULL )
  645. rc = -ENOMEM;
  646. else {
  647. union SafeCast mine;
  648. mine.ptr = userToken;
  649. newElement->event.xHvLpEvent.xSubtype = 5;
  650. newElement->event.xHvLpEvent.xCorrelationToken = mine.ptrAsU64;
  651. newElement->event.xHvLpEvent.x.xSubtypeData = ('M'<<24)+('F'<<16)+('M'<<8)+('D'<<0);
  652. newElement->event.xUnion.xAllocData.xTargetLp = targetLp;
  653. newElement->event.xUnion.xAllocData.xType = type;
  654. newElement->event.xUnion.xAllocData.xCount = count;
  655. newElement->hdlr = hdlr;
  656. rc = signalEvent(newElement);
  657. }
  659. if ( (rc != 0) && (hdlr != NULL) )
  660. (*hdlr)( userToken, rc );
  661. }
  663. /*
  664.  * Global kernel interface to tell the VSP object in the primary
  665.  * partition to power this partition off.
  666.  */
  667. void mf_powerOff( void )
  668. {
  669. printk( KERN_INFO "mf.c: Down it goes...n" );
  670. signalCEMsg( "x00x00x00x4Dx00x00x00x00x00x00x00x00", NULL );
  671. for (;;);
  672. }
  674. /*
  675.  * Global kernel interface to tell the VSP object in the primary
  676.  * partition to reboot this partition.
  677.  */
  678. void mf_reboot( void )
  679. {
  680. printk( KERN_INFO "mf.c: Preparing to bounce...n" );
  681. signalCEMsg( "x00x00x00x4Ex00x00x00x00x00x00x00x00", NULL );
  682. for (;;);
  683. }
  685. /*
  686.  * Display a single word SRC onto the VSP control panel.
  687.  */
  688. void mf_displaySrc( u32 word )
  689. {
  690. u8 ce[12];
  692. memcpy( ce, "x00x00x00x4Ax00x00x00x01x00x00x00x00", 12 );
  693. ce[8] = word>>24;
  694. ce[9] = word>>16;
  695. ce[10] = word>>8;
  696. ce[11] = word;
  697. signalCEMsg( ce, NULL );
  698. }
  700. /*
  701.  * Display a single word SRC of the form "PROGXXXX" on the VSP control panel.
  702.  */
  703. void mf_displayProgress( u16 value )
  704. {
  705. u8 ce[12];
  706. u8 src[72];
  708. memcpy( ce, "x00x00x04x4Ax00x00x00x48x00x00x00x00", 12 );
  709. memcpy( src,
  710. "x01x00x00x01"
  711. "x00x00x00x00"
  712. "x00x00x00x00"
  713. "x00x00x00x00"
  714. "x00x00x00x00"
  715. "x00x00x00x00"
  716. "x00x00x00x00"
  717. "x00x00x00x00"
  718. "x00x00x00x00"
  719. "x00x00x00x00"
  720. "PROGxxxx"
  721. "                        ",
  722. 72 );
  723. src[6] = value>>8;
  724. src[7] = value&255;
  725. src[44] = "0123456789ABCDEF"[(value>>12)&15];
  726. src[45] = "0123456789ABCDEF"[(value>>8)&15];
  727. src[46] = "0123456789ABCDEF"[(value>>4)&15];
  728. src[47] = "0123456789ABCDEF"[value&15];
  729. dmaAndSignalCEMsg( ce, NULL, src, sizeof(src), 9*64*1024 );
  730. }
  732. /*
  733.  * Clear the VSP control panel.  Used to "erase" an SRC that was
  734.  * previously displayed.
  735.  */
  736. void mf_clearSrc( void )
  737. {
  738. signalCEMsg( "x00x00x00x4Bx00x00x00x00x00x00x00x00", NULL );
  739. }
  741. /*
  742.  * Initialization code here.
  743.  */
  744. void mf_init( void )
  745. {
  746. int i;
  748.     /* initialize */
  749. spin_lock_init( &spinlock );
  750. for ( i = 0; i < sizeof(prealloc)/sizeof(*prealloc); ++i )
  751. free( &prealloc[i] );
  752. HvLpEvent_registerHandler( HvLpEvent_Type_MachineFac, &hvHandler );
  754. /* virtual continue ack */
  755. signalCEMsg( "x00x00x00x57x00x00x00x00x00x00x00x00", NULL );
  757. /* initialization complete */
  758. printk( KERN_NOTICE "mf.c: iSeries Linux LPAR Machine Facilities initializedn" );
  760. iSeries_proc_callback(&mf_proc_init);
  761. }
  763. void mf_setSide(char side)
  764. {
  765. int rc = 0;
  766. u64 newSide = 0;
  767. struct VspCmdData myVspCmd;
  769. memset(&myVspCmd, 0, sizeof(myVspCmd));
  770. if (side == 'A')
  771. newSide = 0;
  772. else if (side == 'B')
  773. newSide = 1;
  774. else if (side == 'C')
  775. newSide = 2; 
  776. else
  777. newSide = 3;
  779. myVspCmd.xSubData.xFunction02SelectIplTypeIn.xIplType = newSide;
  780. myVspCmd.xCmd = 10;
  782. rc = signalVspInstruction(&myVspCmd);
  783. }
  785. char mf_getSide(void)
  786. {
  787. char returnValue = ' ';
  788. int rc = 0;
  789. struct VspCmdData myVspCmd;
  791. memset(&myVspCmd, 0, sizeof(myVspCmd));
  792. myVspCmd.xCmd = 2;
  793. myVspCmd.xSubData.xFunction02SelectIplTypeIn.xIplType = 0;
  794. mb();
  795. rc = signalVspInstruction(&myVspCmd);
  797. if (rc != 0)
  798. {
  799. return returnValue;
  800. } else {
  801. if (myVspCmd.xRc == 0)
  802. {
  803. if (myVspCmd.xSubData.xGetIplTypeOut.xIplType == 0)
  804. returnValue = 'A';
  805. else if (myVspCmd.xSubData.xGetIplTypeOut.xIplType == 1)
  806. returnValue = 'B';
  807. else if (myVspCmd.xSubData.xGetIplTypeOut.xIplType == 2)
  808. returnValue = 'C';
  809. else
  810. returnValue = 'D';
  811. }
  812. }
  814. return returnValue;
  815. }
  817. void mf_getSrcHistory(char *buffer, int size)
  818. {
  819.     /*    struct IplTypeReturnStuff returnStuff;
  820.      struct StackElement * newElement = newStackElement();
  821.      int rc = 0;
  822.      char *pages[4];
  824.      pages[0] = kmalloc(4096, GFP_ATOMIC);
  825.      pages[1] = kmalloc(4096, GFP_ATOMIC);
  826.      pages[2] = kmalloc(4096, GFP_ATOMIC);
  827.      pages[3] = kmalloc(4096, GFP_ATOMIC);
  828.      if (( newElement == NULL ) || (pages[0] == NULL) || (pages[1] == NULL) || (pages[2] == NULL) || (pages[3] == NULL))
  829.      rc = -ENOMEM;
  830.      else
  831.      {
  832.      returnStuff.xType = 0;
  833.      returnStuff.xRc = 0;
  834.      returnStuff.xDone = 0;
  835.      newElement->event.xHvLpEvent.xSubtype = 6;
  836.      newElement->event.xHvLpEvent.x.xSubtypeData = ('M'<<24)+('F'<<16)+('V'<<8)+('I'<<0);
  837.      newElement->event.xUnion.xVspCmd.xEvent = &returnStuff;
  838.      newElement->event.xUnion.xVspCmd.xCmd = 4;
  839.      newElement->event.xUnion.xVspCmd.xLpIndex = HvLpConfig_getLpIndex();
  840.      newElement->event.xUnion.xVspCmd.xRc = 0xFF;
  841.      newElement->event.xUnion.xVspCmd.xReserved1 = 0;
  842.      newElement->event.xUnion.xVspCmd.xSubData.xGetSrcHistoryIn.xPage[0] = (0x8000000000000000ULL | virt_to_absolute((unsigned long)pages[0]));
  843.      newElement->event.xUnion.xVspCmd.xSubData.xGetSrcHistoryIn.xPage[1] = (0x8000000000000000ULL | virt_to_absolute((unsigned long)pages[1]));
  844.      newElement->event.xUnion.xVspCmd.xSubData.xGetSrcHistoryIn.xPage[2] = (0x8000000000000000ULL | virt_to_absolute((unsigned long)pages[2]));
  845.      newElement->event.xUnion.xVspCmd.xSubData.xGetSrcHistoryIn.xPage[3] = (0x8000000000000000ULL | virt_to_absolute((unsigned long)pages[3]));
  846.      mb();
  847.      rc = signalEvent(newElement);
  848.      }
  850.      if (rc != 0)
  851.      {
  852.      return;
  853.      }
  854.      else
  855.      {
  856.      while (returnStuff.xDone != 1)
  857.      {
  858.      udelay(10);
  859.      }
  861.      if (returnStuff.xRc == 0)
  862.      {
  863.      memcpy(buffer, pages[0], size);
  864.      }
  865.      }
  867.      kfree(pages[0]);
  868.      kfree(pages[1]);
  869.      kfree(pages[2]);
  870.      kfree(pages[3]);*/
  871. }
  873. void mf_setCmdLine(const char *cmdline, int size, u64 side)
  874. {
  875. struct VspCmdData myVspCmd;
  876. int rc = 0;
  877. dma_addr_t dma_addr = 0;
  878. char *page = pci_alloc_consistent(iSeries_vio_dev, size, &dma_addr);
  880. if (page == NULL) {
  881. printk(KERN_ERR "mf.c: couldn't allocate memory to set command linen");
  882. return;
  883. }
  885. copy_from_user(page, cmdline, size);
  887. memset(&myVspCmd, 0, sizeof(myVspCmd));
  888. myVspCmd.xCmd = 31;
  889. myVspCmd.xSubData.xSetKernelCmdLineIn.xToken = dma_addr;
  890. myVspCmd.xSubData.xSetKernelCmdLineIn.xAddressType = HvLpDma_AddressType_TceIndex;
  891. myVspCmd.xSubData.xSetKernelCmdLineIn.xSide = side;
  892. myVspCmd.xSubData.xSetKernelCmdLineIn.xTransferLength = size;
  893. mb();
  894. rc = signalVspInstruction(&myVspCmd);
  896. pci_free_consistent(iSeries_vio_dev, size, page, dma_addr);
  897. }
  899. int mf_getCmdLine(char *cmdline, int *size, u64 side)
  900. {
  901. struct VspCmdData myVspCmd;
  902. int rc = 0;
  903. int len = *size;
  904. dma_addr_t dma_addr = pci_map_single(iSeries_vio_dev, cmdline, *size, PCI_DMA_FROMDEVICE);
  906. memset(cmdline, 0, *size);
  907. memset(&myVspCmd, 0, sizeof(myVspCmd));
  908. myVspCmd.xCmd = 33;
  909. myVspCmd.xSubData.xGetKernelCmdLineIn.xToken = dma_addr;
  910. myVspCmd.xSubData.xGetKernelCmdLineIn.xAddressType = HvLpDma_AddressType_TceIndex;
  911. myVspCmd.xSubData.xGetKernelCmdLineIn.xSide = side;
  912. myVspCmd.xSubData.xGetKernelCmdLineIn.xTransferLength = *size;
  913. mb();
  914. rc = signalVspInstruction(&myVspCmd);
  916. if ( ! rc ) {
  918. if (myVspCmd.xRc == 0)
  919. {
  920. len = myVspCmd.xSubData.xGetKernelCmdLineOut.xTransferLength;
  921. }
  922. /* else
  923. {
  924. memcpy(cmdline, "Bad cmdline", 11);
  925. }
  926. */
  927. }
  929. pci_unmap_single(iSeries_vio_dev, dma_addr, *size, PCI_DMA_FROMDEVICE);
  931. return len;
  932. }
  935. int mf_setVmlinuxChunk(const char *buffer, int size, int offset, u64 side)
  936. {
  937. struct VspCmdData myVspCmd;
  938. int rc = 0;
  940. dma_addr_t dma_addr = 0;
  942. char *page = pci_alloc_consistent(iSeries_vio_dev, size, &dma_addr);
  944. if (page == NULL) {
  945. printk(KERN_ERR "mf.c: couldn't allocate memory to set vmlinux chunkn");
  946. return -ENOMEM;
  947. }
  949. copy_from_user(page, buffer, size);
  950. memset(&myVspCmd, 0, sizeof(myVspCmd));
  952. myVspCmd.xCmd = 30;
  953. myVspCmd.xSubData.xGetKernelImageIn.xToken = dma_addr;
  954. myVspCmd.xSubData.xGetKernelImageIn.xAddressType = HvLpDma_AddressType_TceIndex;
  955. myVspCmd.xSubData.xGetKernelImageIn.xSide = side;
  956. myVspCmd.xSubData.xGetKernelImageIn.xOffset = offset;
  957. myVspCmd.xSubData.xGetKernelImageIn.xTransferLength = size;
  958. mb();
  959. rc = signalVspInstruction(&myVspCmd);
  961. if (rc == 0)
  962. {
  963. if (myVspCmd.xRc == 0)
  964. {
  965. rc = 0;
  966. } else {
  967. rc = -ENOMEM;
  968. }
  969. }
  971. pci_free_consistent(iSeries_vio_dev, size, page, dma_addr);
  973. return rc;
  974. }
  976. int mf_getVmlinuxChunk(char *buffer, int *size, int offset, u64 side)
  977. {
  978. struct VspCmdData myVspCmd;
  979. int rc = 0;
  980. int len = *size;
  982. dma_addr_t dma_addr = pci_map_single(iSeries_vio_dev, buffer, *size, PCI_DMA_FROMDEVICE);
  984. memset(buffer, 0, len);
  986. memset(&myVspCmd, 0, sizeof(myVspCmd));
  987. myVspCmd.xCmd = 32;
  988. myVspCmd.xSubData.xGetKernelImageIn.xToken = dma_addr;
  989. myVspCmd.xSubData.xGetKernelImageIn.xAddressType = HvLpDma_AddressType_TceIndex;
  990. myVspCmd.xSubData.xGetKernelImageIn.xSide = side;
  991. myVspCmd.xSubData.xGetKernelImageIn.xOffset = offset;
  992. myVspCmd.xSubData.xGetKernelImageIn.xTransferLength = len;
  993. mb();
  994. rc = signalVspInstruction(&myVspCmd);
  996. if (rc == 0)
  997. {
  998. if (myVspCmd.xRc == 0)
  999. {
  1000. *size = myVspCmd.xSubData.xGetKernelImageOut.xTransferLength;
  1001. } else {
  1002. rc = -ENOMEM;
  1003. }
  1004. }
  1006. pci_unmap_single(iSeries_vio_dev, dma_addr, len, PCI_DMA_FROMDEVICE);
  1008. return rc;
  1009. }
  1011. int mf_setRtcTime(unsigned long time)
  1012. {
  1013. struct rtc_time tm;
  1015. to_tm(time, &tm);
  1017. return mf_setRtc( &tm );
  1018. }
  1020. struct RtcTimeData
  1021. {
  1022. struct semaphore *xSemaphore;
  1023. struct CeMsgData xCeMsg;
  1024. int xRc;
  1025. };
  1027. void getRtcTimeComplete(void * token, struct CeMsgData *ceMsg)
  1028. {
  1029. struct RtcTimeData *rtc = (struct RtcTimeData *)token;
  1031. memcpy(&(rtc->xCeMsg), ceMsg, sizeof(rtc->xCeMsg));
  1033. rtc->xRc = 0;
  1034. up(rtc->xSemaphore);
  1035. }
  1037. static unsigned long lastsec = 1;
  1039. int mf_getRtcTime(unsigned long *time)
  1040. {
  1041. /*    unsigned long usec, tsec; */
  1043. u32 dataWord1 = *((u32 *)(&xSpCommArea.xBcdTimeAtIplStart));
  1044. u32 dataWord2 = *(((u32 *)&(xSpCommArea.xBcdTimeAtIplStart)) + 1);
  1045. int year = 1970;
  1046. int year1 = ( dataWord1 >> 24 ) & 0x000000FF;
  1047. int year2 = ( dataWord1 >> 16 ) & 0x000000FF;
  1048. int sec = ( dataWord1 >> 8 ) & 0x000000FF;
  1049. int min = dataWord1 & 0x000000FF;
  1050. int hour = ( dataWord2 >> 24 ) & 0x000000FF;
  1051. int day = ( dataWord2 >> 8 ) & 0x000000FF;
  1052. int mon = dataWord2 & 0x000000FF;
  1054. BCD_TO_BIN(sec);
  1055. BCD_TO_BIN(min);
  1056. BCD_TO_BIN(hour);
  1057. BCD_TO_BIN(day);
  1058. BCD_TO_BIN(mon);
  1059. BCD_TO_BIN(year1);
  1060. BCD_TO_BIN(year2);
  1061. year = year1 * 100 + year2;
  1063. *time = mktime(year, mon, day, hour, min, sec);
  1065. *time += ( jiffies / HZ );
  1066.     
  1067. /* Now THIS is a nasty hack!
  1068.  * It ensures that the first two calls to mf_getRtcTime get different
  1069.  * answers.  That way the loop in init_time (time.c) will not think
  1070.  * the clock is stuck.
  1071.  */
  1072. if ( lastsec ) {
  1073. *time -= lastsec;
  1074. --lastsec;
  1075. }
  1076.     
  1077. return 0;
  1079. }
  1081. int mf_getRtc( struct rtc_time * tm )
  1082. {
  1084. struct CeMsgCompleteData ceComplete;
  1085. struct RtcTimeData rtcData;
  1086. int rc = 0;
  1087. DECLARE_MUTEX_LOCKED(Semaphore);
  1089. memset(&ceComplete, 0, sizeof(ceComplete));
  1090. memset(&rtcData, 0, sizeof(rtcData));
  1092. rtcData.xSemaphore = &Semaphore;
  1094. ceComplete.xHdlr = &getRtcTimeComplete;
  1095. ceComplete.xToken = (void *)&rtcData;
  1097. rc = signalCEMsg( "x00x00x00x40x00x00x00x00x00x00x00x00", &ceComplete );
  1099. if ( rc == 0 )
  1100. {
  1101. down(&Semaphore);
  1103. if ( rtcData.xRc == 0)
  1104. {
  1105. if ( ( rtcData.xCeMsg.xCEMsg[2] == 0xa9 ) ||
  1106.      ( rtcData.xCeMsg.xCEMsg[2] == 0xaf ) ) {
  1107. /* TOD clock is not set */
  1108. tm->tm_sec = 1;
  1109. tm->tm_min = 1;
  1110. tm->tm_hour = 1;
  1111. tm->tm_mday = 10;
  1112. tm->tm_mon = 8;
  1113. tm->tm_year = 71;
  1114. mf_setRtc( tm );
  1115. }
  1116. {
  1117. u32 dataWord1 = *((u32 *)(rtcData.xCeMsg.xCEMsg+4));
  1118. u32 dataWord2 = *((u32 *)(rtcData.xCeMsg.xCEMsg+8));
  1119. u8 year = (dataWord1 >> 16 ) & 0x000000FF;
  1120. u8 sec = ( dataWord1 >> 8 ) & 0x000000FF;
  1121. u8 min = dataWord1 & 0x000000FF;
  1122. u8 hour = ( dataWord2 >> 24 ) & 0x000000FF;
  1123. u8 day = ( dataWord2 >> 8 ) & 0x000000FF;
  1124. u8 mon = dataWord2 & 0x000000FF;
  1126. BCD_TO_BIN(sec);
  1127. BCD_TO_BIN(min);
  1128. BCD_TO_BIN(hour);
  1129. BCD_TO_BIN(day);
  1130. BCD_TO_BIN(mon);
  1131. BCD_TO_BIN(year);
  1133. if ( year <= 69 )
  1134. year += 100;
  1135.     
  1136. tm->tm_sec = sec;
  1137. tm->tm_min = min;
  1138. tm->tm_hour = hour;
  1139. tm->tm_mday = day;
  1140. tm->tm_mon = mon;
  1141. tm->tm_year = year;
  1142. }
  1143. } else {
  1144. rc = rtcData.xRc;
  1145. tm->tm_sec = 0;
  1146. tm->tm_min = 0;
  1147. tm->tm_hour = 0;
  1148. tm->tm_mday = 15;
  1149. tm->tm_mon = 5;
  1150. tm->tm_year = 52;
  1152. }
  1153. tm->tm_wday = 0;
  1154. tm->tm_yday = 0;
  1155. tm->tm_isdst = 0;
  1157. }
  1159. return rc;
  1161. }
  1163. int mf_setRtc(struct rtc_time * tm)
  1164. {
  1165. char ceTime[12] = "x00x00x00x41x00x00x00x00x00x00x00x00";
  1166. int rc = 0;
  1167. u8 day, mon, hour, min, sec, y1, y2;
  1168. unsigned year;
  1169.     
  1170. year = 1900 + tm->tm_year;
  1171. y1 = year / 100;
  1172. y2 = year % 100;
  1173.     
  1174. sec = tm->tm_sec;
  1175. min = tm->tm_min;
  1176. hour = tm->tm_hour;
  1177. day = tm->tm_mday;
  1178. mon = tm->tm_mon + 1;
  1179.     
  1180. BIN_TO_BCD(sec);
  1181. BIN_TO_BCD(min);
  1182. BIN_TO_BCD(hour);
  1183. BIN_TO_BCD(mon);
  1184. BIN_TO_BCD(day);
  1185. BIN_TO_BCD(y1);
  1186. BIN_TO_BCD(y2);
  1188. ceTime[4] = y1;
  1189. ceTime[5] = y2;
  1190. ceTime[6] = sec;
  1191. ceTime[7] = min;
  1192. ceTime[8] = hour;
  1193. ceTime[10] = day;
  1194. ceTime[11] = mon;
  1195.    
  1196. rc = signalCEMsg( ceTime, NULL );
  1198. return rc;
  1199. }