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

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

Linux/Unix编程

开发平台：

Unix_Linux

head.S：源码内容
  1. /*
  2.  * Here is where the ball gets rolling as far as the kernel is concerned.
  3.  * When control is transferred to _start, the bootload has already
  4.  * loaded us to the correct address.  All that's left to do here is
  5.  * to set up the kernel's global pointer and jump to the kernel
  6.  * entry point.
  7.  *
  8.  * Copyright (C) 1998-2001 Hewlett-Packard Co
  9.  * David Mosberger-Tang <davidm@hpl.hp.com>
  10.  * Stephane Eranian <eranian@hpl.hp.com>
  11.  * Copyright (C) 1999 VA Linux Systems
  12.  * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
  13.  * Copyright (C) 1999 Intel Corp.
  14.  * Copyright (C) 1999 Asit Mallick <Asit.K.Mallick@intel.com>
  15.  * Copyright (C) 1999 Don Dugger <Don.Dugger@intel.com>
  16.  */
  18. #include <linux/config.h>
  20. #include <asm/asmmacro.h>
  21. #include <asm/fpu.h>
  22. #include <asm/kregs.h>
  23. #include <asm/mmu_context.h>
  24. #include <asm/offsets.h>
  25. #include <asm/pal.h>
  26. #include <asm/pgtable.h>
  27. #include <asm/processor.h>
  28. #include <asm/ptrace.h>
  29. #include <asm/system.h>
  31. .section __special_page_section,"ax"
  33. .global empty_zero_page
  34. empty_zero_page:
  35. .skip PAGE_SIZE
  37. .global swapper_pg_dir
  38. swapper_pg_dir:
  39. .skip PAGE_SIZE
  41. .rodata
  42. halt_msg:
  43. stringz "Halting kerneln"
  45. .text
  47. .global start_ap
  49. /*
  50.  * Start the kernel.  When the bootloader passes control to _start(), r28
  51.  * points to the address of the boot parameter area.  Execution reaches
  52.  * here in physical mode.
  53.  */
  54. GLOBAL_ENTRY(_start)
  55. start_ap:
  56. .prologue
  57. .save rp, r4 // terminate unwind chain with a NULL rp
  58. mov r4=r0
  59. .body
  61. /*
  62.  * Initialize the region register for region 7 and install a translation register
  63.  * that maps the kernel's text and data:
  64.  */
  65. rsm psr.i | psr.ic
  66. mov r16=((ia64_rid(IA64_REGION_ID_KERNEL, PAGE_OFFSET) << 8) | (IA64_GRANULE_SHIFT << 2))
  67. ;;
  68. srlz.i
  69. mov r18=KERNEL_TR_PAGE_SHIFT<<2
  70. movl r17=KERNEL_START
  71. ;;
  72. mov rr[r17]=r16
  73. mov cr.itir=r18
  74. mov cr.ifa=r17
  75. mov r16=IA64_TR_KERNEL
  76. movl r18=((1 << KERNEL_TR_PAGE_SHIFT) | PAGE_KERNEL)
  77. ;;
  78. srlz.i
  79. ;;
  80. itr.i itr[r16]=r18
  81. ;;
  82. itr.d dtr[r16]=r18
  83. ;;
  84. srlz.i
  86. /*
  87.  * Switch into virtual mode:
  88.  */
  89. movl r16=(IA64_PSR_IT|IA64_PSR_IC|IA64_PSR_DT|IA64_PSR_RT|IA64_PSR_DFH|IA64_PSR_BN 
  90.   |IA64_PSR_DI)
  91. ;;
  92. mov cr.ipsr=r16
  93. movl r17=1f
  94. ;;
  95. mov cr.iip=r17
  96. mov cr.ifs=r0
  97. ;;
  98. rfi
  99. ;;
  100. 1: // now we are in virtual mode
  102. // set IVT entry point---can't access I/O ports without it
  103. movl r3=ia64_ivt
  104. ;;
  105. mov cr.iva=r3
  106. movl r2=FPSR_DEFAULT
  107. ;;
  108. srlz.i
  109. movl gp=__gp
  111. mov ar.fpsr=r2
  112. ;;
  114. #ifdef CONFIG_IA64_EARLY_PRINTK
  115. mov r3=(6<<8) | (IA64_GRANULE_SHIFT<<2)
  116. movl r2=6<<61
  117. ;;
  118. mov rr[r2]=r3
  119. ;;
  120. srlz.i
  121. ;;
  122. #endif
  124. #define isAP p2 // are we an Application Processor?
  125. #define isBP p3 // are we the Bootstrap Processor?
  127. #ifdef CONFIG_SMP
  128. /*
  129.  * Find the init_task for the currently booting CPU.  At poweron, and in
  130.  * UP mode, cpucount is 0.
  131.  */
  132. movl r3=cpucount
  133.   ;;
  134. ld4 r3=[r3] // r3 <- smp_processor_id()
  135. movl r2=init_tasks
  136. ;;
  137. shladd r2=r3,3,r2
  138. ;;
  139. ld8 r2=[r2]
  140. #else
  141. mov r3=0
  142. movl r2=init_task_union
  143. ;;
  144. #endif
  145. cmp4.ne isAP,isBP=r3,r0
  146. ;; // RAW on r2
  147. extr r3=r2,0,61 // r3 == phys addr of task struct
  148. mov r16=KERNEL_TR_PAGE_NUM
  149. ;;
  151. // load the "current" pointer (r13) and ar.k6 with the current task
  152. mov r13=r2
  153. mov IA64_KR(CURRENT)=r3 // Physical address
  155. // initialize k4 to a safe value (64-128MB is mapped by TR_KERNEL)
  156. mov IA64_KR(CURRENT_STACK)=r16
  157. /*
  158.  * Reserve space at the top of the stack for "struct pt_regs".  Kernel threads
  159.  * don't store interesting values in that structure, but the space still needs
  160.  * to be there because time-critical stuff such as the context switching can
  161.  * be implemented more efficiently (for example, __switch_to()
  162.  * always sets the psr.dfh bit of the task it is switching to).
  163.  */
  164. addl r12=IA64_STK_OFFSET-IA64_PT_REGS_SIZE-16,r2
  165. addl r2=IA64_RBS_OFFSET,r2 // initialize the RSE
  166. mov ar.rsc=0 // place RSE in enforced lazy mode
  167. ;;
  168. loadrs // clear the dirty partition
  169. ;;
  170. mov ar.bspstore=r2 // establish the new RSE stack
  171. ;;
  172. mov ar.rsc=0x3 // place RSE in eager mode
  174. (isBP) dep r28=-1,r28,61,3 // make address virtual
  175. (isBP) movl r2=ia64_boot_param
  176. ;;
  177. (isBP) st8 [r2]=r28 // save the address of the boot param area passed by the bootloader
  179. #ifdef CONFIG_IA64_EARLY_PRINTK
  180. .rodata
  181. alive_msg:
  182. stringz "I'm alive and welln"
  183. alive_msg_end:
  184. .previous
  186. alloc r2=ar.pfs,0,0,2,0
  187. movl out0=alive_msg
  188. movl out1=alive_msg_end-alive_msg-1
  189. ;;
  190. br.call.sptk.many rp=early_printk
  191. 1: // force new bundle
  192. #endif /* CONFIG_IA64_EARLY_PRINTK */
  194. #ifdef CONFIG_SMP
  195. (isAP) br.call.sptk.many rp=start_secondary
  196. .ret0:
  197. (isAP) br.cond.sptk self
  198. #endif
  200. // This is executed by the bootstrap processor (bsp) only:
  202. #ifdef CONFIG_IA64_FW_EMU
  203. // initialize PAL & SAL emulator:
  204. br.call.sptk.many rp=sys_fw_init
  205. .ret1:
  206. #endif
  207. br.call.sptk.many rp=start_kernel
  208. .ret2: addl r3=@ltoff(halt_msg),gp
  209. ;;
  210. alloc r2=ar.pfs,8,0,2,0
  211. ;;
  212. ld8 out0=[r3]
  213. br.call.sptk.many b0=console_print
  214. self: br.sptk.many self // endless loop
  215. END(_start)
  217. GLOBAL_ENTRY(ia64_save_debug_regs)
  218. alloc r16=ar.pfs,1,0,0,0
  219. mov r20=ar.lc // preserve ar.lc
  220. mov ar.lc=IA64_NUM_DBG_REGS-1
  221. mov r18=0
  222. add r19=IA64_NUM_DBG_REGS*8,in0
  223. ;;
  224. 1: mov r16=dbr[r18]
  225. #ifdef CONFIG_ITANIUM
  226. ;;
  227. srlz.d
  228. #endif
  229. mov r17=ibr[r18]
  230. add r18=1,r18
  231. ;;
  232. st8.nta [in0]=r16,8
  233. st8.nta [r19]=r17,8
  234. br.cloop.sptk.many 1b
  235. ;;
  236. mov ar.lc=r20 // restore ar.lc
  237. br.ret.sptk.many rp
  238. END(ia64_save_debug_regs)
  240. GLOBAL_ENTRY(ia64_load_debug_regs)
  241. alloc r16=ar.pfs,1,0,0,0
  242. lfetch.nta [in0]
  243. mov r20=ar.lc // preserve ar.lc
  244. add r19=IA64_NUM_DBG_REGS*8,in0
  245. mov ar.lc=IA64_NUM_DBG_REGS-1
  246. mov r18=-1
  247. ;;
  248. 1: ld8.nta r16=[in0],8
  249. ld8.nta r17=[r19],8
  250. add r18=1,r18
  251. ;;
  252. mov dbr[r18]=r16
  253. #ifdef CONFIG_ITANIUM
  254. ;;
  255. srlz.d // Errata 132 (NoFix status)
  256. #endif
  257. mov ibr[r18]=r17
  258. br.cloop.sptk.many 1b
  259. ;;
  260. mov ar.lc=r20 // restore ar.lc
  261. br.ret.sptk.many rp
  262. END(ia64_load_debug_regs)
  264. GLOBAL_ENTRY(__ia64_save_fpu)
  265. alloc r2=ar.pfs,1,0,0,0
  266. adds r3=16,in0
  267. ;;
  268. stf.spill.nta [in0]=f32,32
  269. stf.spill.nta [ r3]=f33,32
  270. ;;
  271. stf.spill.nta [in0]=f34,32
  272. stf.spill.nta [ r3]=f35,32
  273. ;;
  274. stf.spill.nta [in0]=f36,32
  275. stf.spill.nta [ r3]=f37,32
  276. ;;
  277. stf.spill.nta [in0]=f38,32
  278. stf.spill.nta [ r3]=f39,32
  279. ;;
  280. stf.spill.nta [in0]=f40,32
  281. stf.spill.nta [ r3]=f41,32
  282. ;;
  283. stf.spill.nta [in0]=f42,32
  284. stf.spill.nta [ r3]=f43,32
  285. ;;
  286. stf.spill.nta [in0]=f44,32
  287. stf.spill.nta [ r3]=f45,32
  288. ;;
  289. stf.spill.nta [in0]=f46,32
  290. stf.spill.nta [ r3]=f47,32
  291. ;;
  292. stf.spill.nta [in0]=f48,32
  293. stf.spill.nta [ r3]=f49,32
  294. ;;
  295. stf.spill.nta [in0]=f50,32
  296. stf.spill.nta [ r3]=f51,32
  297. ;;
  298. stf.spill.nta [in0]=f52,32
  299. stf.spill.nta [ r3]=f53,32
  300. ;;
  301. stf.spill.nta [in0]=f54,32
  302. stf.spill.nta [ r3]=f55,32
  303. ;;
  304. stf.spill.nta [in0]=f56,32
  305. stf.spill.nta [ r3]=f57,32
  306. ;;
  307. stf.spill.nta [in0]=f58,32
  308. stf.spill.nta [ r3]=f59,32
  309. ;;
  310. stf.spill.nta [in0]=f60,32
  311. stf.spill.nta [ r3]=f61,32
  312. ;;
  313. stf.spill.nta [in0]=f62,32
  314. stf.spill.nta [ r3]=f63,32
  315. ;;
  316. stf.spill.nta [in0]=f64,32
  317. stf.spill.nta [ r3]=f65,32
  318. ;;
  319. stf.spill.nta [in0]=f66,32
  320. stf.spill.nta [ r3]=f67,32
  321. ;;
  322. stf.spill.nta [in0]=f68,32
  323. stf.spill.nta [ r3]=f69,32
  324. ;;
  325. stf.spill.nta [in0]=f70,32
  326. stf.spill.nta [ r3]=f71,32
  327. ;;
  328. stf.spill.nta [in0]=f72,32
  329. stf.spill.nta [ r3]=f73,32
  330. ;;
  331. stf.spill.nta [in0]=f74,32
  332. stf.spill.nta [ r3]=f75,32
  333. ;;
  334. stf.spill.nta [in0]=f76,32
  335. stf.spill.nta [ r3]=f77,32
  336. ;;
  337. stf.spill.nta [in0]=f78,32
  338. stf.spill.nta [ r3]=f79,32
  339. ;;
  340. stf.spill.nta [in0]=f80,32
  341. stf.spill.nta [ r3]=f81,32
  342. ;;
  343. stf.spill.nta [in0]=f82,32
  344. stf.spill.nta [ r3]=f83,32
  345. ;;
  346. stf.spill.nta [in0]=f84,32
  347. stf.spill.nta [ r3]=f85,32
  348. ;;
  349. stf.spill.nta [in0]=f86,32
  350. stf.spill.nta [ r3]=f87,32
  351. ;;
  352. stf.spill.nta [in0]=f88,32
  353. stf.spill.nta [ r3]=f89,32
  354. ;;
  355. stf.spill.nta [in0]=f90,32
  356. stf.spill.nta [ r3]=f91,32
  357. ;;
  358. stf.spill.nta [in0]=f92,32
  359. stf.spill.nta [ r3]=f93,32
  360. ;;
  361. stf.spill.nta [in0]=f94,32
  362. stf.spill.nta [ r3]=f95,32
  363. ;;
  364. stf.spill.nta [in0]=f96,32
  365. stf.spill.nta [ r3]=f97,32
  366. ;;
  367. stf.spill.nta [in0]=f98,32
  368. stf.spill.nta [ r3]=f99,32
  369. ;;
  370. stf.spill.nta [in0]=f100,32
  371. stf.spill.nta [ r3]=f101,32
  372. ;;
  373. stf.spill.nta [in0]=f102,32
  374. stf.spill.nta [ r3]=f103,32
  375. ;;
  376. stf.spill.nta [in0]=f104,32
  377. stf.spill.nta [ r3]=f105,32
  378. ;;
  379. stf.spill.nta [in0]=f106,32
  380. stf.spill.nta [ r3]=f107,32
  381. ;;
  382. stf.spill.nta [in0]=f108,32
  383. stf.spill.nta [ r3]=f109,32
  384. ;;
  385. stf.spill.nta [in0]=f110,32
  386. stf.spill.nta [ r3]=f111,32
  387. ;;
  388. stf.spill.nta [in0]=f112,32
  389. stf.spill.nta [ r3]=f113,32
  390. ;;
  391. stf.spill.nta [in0]=f114,32
  392. stf.spill.nta [ r3]=f115,32
  393. ;;
  394. stf.spill.nta [in0]=f116,32
  395. stf.spill.nta [ r3]=f117,32
  396. ;;
  397. stf.spill.nta [in0]=f118,32
  398. stf.spill.nta [ r3]=f119,32
  399. ;;
  400. stf.spill.nta [in0]=f120,32
  401. stf.spill.nta [ r3]=f121,32
  402. ;;
  403. stf.spill.nta [in0]=f122,32
  404. stf.spill.nta [ r3]=f123,32
  405. ;;
  406. stf.spill.nta [in0]=f124,32
  407. stf.spill.nta [ r3]=f125,32
  408. ;;
  409. stf.spill.nta [in0]=f126,32
  410. stf.spill.nta [ r3]=f127,32
  411. br.ret.sptk.many rp
  412. END(__ia64_save_fpu)
  414. GLOBAL_ENTRY(__ia64_load_fpu)
  415. alloc r2=ar.pfs,1,0,0,0
  416. adds r3=16,in0
  417. ;;
  418. ldf.fill.nta f32=[in0],32
  419. ldf.fill.nta f33=[ r3],32
  420. ;;
  421. ldf.fill.nta f34=[in0],32
  422. ldf.fill.nta f35=[ r3],32
  423. ;;
  424. ldf.fill.nta f36=[in0],32
  425. ldf.fill.nta f37=[ r3],32
  426. ;;
  427. ldf.fill.nta f38=[in0],32
  428. ldf.fill.nta f39=[ r3],32
  429. ;;
  430. ldf.fill.nta f40=[in0],32
  431. ldf.fill.nta f41=[ r3],32
  432. ;;
  433. ldf.fill.nta f42=[in0],32
  434. ldf.fill.nta f43=[ r3],32
  435. ;;
  436. ldf.fill.nta f44=[in0],32
  437. ldf.fill.nta f45=[ r3],32
  438. ;;
  439. ldf.fill.nta f46=[in0],32
  440. ldf.fill.nta f47=[ r3],32
  441. ;;
  442. ldf.fill.nta f48=[in0],32
  443. ldf.fill.nta f49=[ r3],32
  444. ;;
  445. ldf.fill.nta f50=[in0],32
  446. ldf.fill.nta f51=[ r3],32
  447. ;;
  448. ldf.fill.nta f52=[in0],32
  449. ldf.fill.nta f53=[ r3],32
  450. ;;
  451. ldf.fill.nta f54=[in0],32
  452. ldf.fill.nta f55=[ r3],32
  453. ;;
  454. ldf.fill.nta f56=[in0],32
  455. ldf.fill.nta f57=[ r3],32
  456. ;;
  457. ldf.fill.nta f58=[in0],32
  458. ldf.fill.nta f59=[ r3],32
  459. ;;
  460. ldf.fill.nta f60=[in0],32
  461. ldf.fill.nta f61=[ r3],32
  462. ;;
  463. ldf.fill.nta f62=[in0],32
  464. ldf.fill.nta f63=[ r3],32
  465. ;;
  466. ldf.fill.nta f64=[in0],32
  467. ldf.fill.nta f65=[ r3],32
  468. ;;
  469. ldf.fill.nta f66=[in0],32
  470. ldf.fill.nta f67=[ r3],32
  471. ;;
  472. ldf.fill.nta f68=[in0],32
  473. ldf.fill.nta f69=[ r3],32
  474. ;;
  475. ldf.fill.nta f70=[in0],32
  476. ldf.fill.nta f71=[ r3],32
  477. ;;
  478. ldf.fill.nta f72=[in0],32
  479. ldf.fill.nta f73=[ r3],32
  480. ;;
  481. ldf.fill.nta f74=[in0],32
  482. ldf.fill.nta f75=[ r3],32
  483. ;;
  484. ldf.fill.nta f76=[in0],32
  485. ldf.fill.nta f77=[ r3],32
  486. ;;
  487. ldf.fill.nta f78=[in0],32
  488. ldf.fill.nta f79=[ r3],32
  489. ;;
  490. ldf.fill.nta f80=[in0],32
  491. ldf.fill.nta f81=[ r3],32
  492. ;;
  493. ldf.fill.nta f82=[in0],32
  494. ldf.fill.nta f83=[ r3],32
  495. ;;
  496. ldf.fill.nta f84=[in0],32
  497. ldf.fill.nta f85=[ r3],32
  498. ;;
  499. ldf.fill.nta f86=[in0],32
  500. ldf.fill.nta f87=[ r3],32
  501. ;;
  502. ldf.fill.nta f88=[in0],32
  503. ldf.fill.nta f89=[ r3],32
  504. ;;
  505. ldf.fill.nta f90=[in0],32
  506. ldf.fill.nta f91=[ r3],32
  507. ;;
  508. ldf.fill.nta f92=[in0],32
  509. ldf.fill.nta f93=[ r3],32
  510. ;;
  511. ldf.fill.nta f94=[in0],32
  512. ldf.fill.nta f95=[ r3],32
  513. ;;
  514. ldf.fill.nta f96=[in0],32
  515. ldf.fill.nta f97=[ r3],32
  516. ;;
  517. ldf.fill.nta f98=[in0],32
  518. ldf.fill.nta f99=[ r3],32
  519. ;;
  520. ldf.fill.nta f100=[in0],32
  521. ldf.fill.nta f101=[ r3],32
  522. ;;
  523. ldf.fill.nta f102=[in0],32
  524. ldf.fill.nta f103=[ r3],32
  525. ;;
  526. ldf.fill.nta f104=[in0],32
  527. ldf.fill.nta f105=[ r3],32
  528. ;;
  529. ldf.fill.nta f106=[in0],32
  530. ldf.fill.nta f107=[ r3],32
  531. ;;
  532. ldf.fill.nta f108=[in0],32
  533. ldf.fill.nta f109=[ r3],32
  534. ;;
  535. ldf.fill.nta f110=[in0],32
  536. ldf.fill.nta f111=[ r3],32
  537. ;;
  538. ldf.fill.nta f112=[in0],32
  539. ldf.fill.nta f113=[ r3],32
  540. ;;
  541. ldf.fill.nta f114=[in0],32
  542. ldf.fill.nta f115=[ r3],32
  543. ;;
  544. ldf.fill.nta f116=[in0],32
  545. ldf.fill.nta f117=[ r3],32
  546. ;;
  547. ldf.fill.nta f118=[in0],32
  548. ldf.fill.nta f119=[ r3],32
  549. ;;
  550. ldf.fill.nta f120=[in0],32
  551. ldf.fill.nta f121=[ r3],32
  552. ;;
  553. ldf.fill.nta f122=[in0],32
  554. ldf.fill.nta f123=[ r3],32
  555. ;;
  556. ldf.fill.nta f124=[in0],32
  557. ldf.fill.nta f125=[ r3],32
  558. ;;
  559. ldf.fill.nta f126=[in0],32
  560. ldf.fill.nta f127=[ r3],32
  561. br.ret.sptk.many rp
  562. END(__ia64_load_fpu)
  564. GLOBAL_ENTRY(__ia64_init_fpu)
  565. stf.spill [sp]=f0 // M3
  566. mov  f32=f0 // F
  567. nop.b  0
  569. ldfps  f33,f34=[sp] // M0
  570. ldfps  f35,f36=[sp] // M1
  571. mov      f37=f0 // F
  572. ;;
  574. setf.s  f38=r0 // M2
  575. setf.s  f39=r0 // M3
  576. mov      f40=f0 // F
  578. ldfps  f41,f42=[sp] // M0
  579. ldfps  f43,f44=[sp] // M1
  580. mov      f45=f0 // F
  582. setf.s  f46=r0 // M2
  583. setf.s  f47=r0 // M3
  584. mov      f48=f0 // F
  586. ldfps  f49,f50=[sp] // M0
  587. ldfps  f51,f52=[sp] // M1
  588. mov      f53=f0 // F
  590. setf.s  f54=r0 // M2
  591. setf.s  f55=r0 // M3
  592. mov      f56=f0 // F
  594. ldfps  f57,f58=[sp] // M0
  595. ldfps  f59,f60=[sp] // M1
  596. mov      f61=f0 // F
  598. setf.s  f62=r0 // M2
  599. setf.s  f63=r0 // M3
  600. mov      f64=f0 // F
  602. ldfps  f65,f66=[sp] // M0
  603. ldfps  f67,f68=[sp] // M1
  604. mov      f69=f0 // F
  606. setf.s  f70=r0 // M2
  607. setf.s  f71=r0 // M3
  608. mov      f72=f0 // F
  610. ldfps  f73,f74=[sp] // M0
  611. ldfps  f75,f76=[sp] // M1
  612. mov      f77=f0 // F
  614. setf.s  f78=r0 // M2
  615. setf.s  f79=r0 // M3
  616. mov      f80=f0 // F
  618. ldfps  f81,f82=[sp] // M0
  619. ldfps  f83,f84=[sp] // M1
  620. mov      f85=f0 // F
  622. setf.s  f86=r0 // M2
  623. setf.s  f87=r0 // M3
  624. mov      f88=f0 // F
  626. /*
  627.  * When the instructions are cached, it would be faster to initialize
  628.  * the remaining registers with simply mov instructions (F-unit).
  629.  * This gets the time down to ~29 cycles.  However, this would use up
  630.  * 33 bundles, whereas continuing with the above pattern yields
  631.  * 10 bundles and ~30 cycles.
  632.  */
  634. ldfps  f89,f90=[sp] // M0
  635. ldfps  f91,f92=[sp] // M1
  636. mov      f93=f0 // F
  638. setf.s  f94=r0 // M2
  639. setf.s  f95=r0 // M3
  640. mov      f96=f0 // F
  642. ldfps  f97,f98=[sp] // M0
  643. ldfps  f99,f100=[sp] // M1
  644. mov      f101=f0 // F
  646. setf.s  f102=r0 // M2
  647. setf.s  f103=r0 // M3
  648. mov      f104=f0 // F
  650. ldfps  f105,f106=[sp] // M0
  651. ldfps  f107,f108=[sp] // M1
  652. mov      f109=f0 // F
  654. setf.s  f110=r0 // M2
  655. setf.s  f111=r0 // M3
  656. mov      f112=f0 // F
  658. ldfps  f113,f114=[sp] // M0
  659. ldfps  f115,f116=[sp] // M1
  660. mov      f117=f0 // F
  662. setf.s  f118=r0 // M2
  663. setf.s  f119=r0 // M3
  664. mov      f120=f0 // F
  666. ldfps  f121,f122=[sp] // M0
  667. ldfps  f123,f124=[sp] // M1
  668. mov      f125=f0 // F
  670. setf.s  f126=r0 // M2
  671. setf.s  f127=r0 // M3
  672. br.ret.sptk.many rp // F
  673. END(__ia64_init_fpu)
  675. /*
  676.  * Switch execution mode from virtual to physical or vice versa.
  677.  *
  678.  * Inputs:
  679.  * r16 = new psr to establish
  680.  *
  681.  * Note: RSE must already be in enforced lazy mode
  682.  */
  683. GLOBAL_ENTRY(ia64_switch_mode)
  684.  {
  685. alloc r2=ar.pfs,0,0,0,0
  686. rsm psr.i | psr.ic // disable interrupts and interrupt collection
  687. mov r15=ip
  688.  }
  689. ;;
  690.  {
  691. flushrs // must be first insn in group
  692. srlz.i
  693. shr.u r19=r15,61 // r19 <- top 3 bits of current IP
  694.  }
  695. ;;
  696. mov cr.ipsr=r16 // set new PSR
  697. add r3=1f-ia64_switch_mode,r15
  698. xor r15=0x7,r19 // flip the region bits
  700. mov r17=ar.bsp
  701. mov r14=rp // get return address into a general register
  703. // switch RSE backing store:
  704. ;;
  705. dep r17=r15,r17,61,3 // make ar.bsp physical or virtual
  706. mov r18=ar.rnat // save ar.rnat
  707. ;;
  708. mov ar.bspstore=r17 // this steps on ar.rnat
  709. dep r3=r15,r3,61,3 // make rfi return address physical or virtual
  710. ;;
  711. mov cr.iip=r3
  712. mov cr.ifs=r0
  713. dep sp=r15,sp,61,3 // make stack pointer physical or virtual
  714. ;;
  715. mov ar.rnat=r18 // restore ar.rnat
  716. dep r14=r15,r14,61,3 // make function return address physical or virtual
  717. rfi // must be last insn in group
  718. ;;
  719. 1: mov rp=r14
  720. br.ret.sptk.many rp
  721. END(ia64_switch_mode)
  723. #ifdef CONFIG_IA64_BRL_EMU
  725. /*
  726.  *  Assembly routines used by brl_emu.c to set preserved register state.
  727.  */
  729. #define SET_REG(reg)
  730.  GLOBAL_ENTRY(ia64_set_##reg);
  731. alloc r16=ar.pfs,1,0,0,0;
  732. mov reg=r32;
  733. ;;
  734. br.ret.sptk.many rp;
  735.  END(ia64_set_##reg)
  737. SET_REG(b1);
  738. SET_REG(b2);
  739. SET_REG(b3);
  740. SET_REG(b4);
  741. SET_REG(b5);
  743. #endif /* CONFIG_IA64_BRL_EMU */
  745. #ifdef CONFIG_SMP
  747. /*
  748.  * This routine handles spinlock contention.  It uses a simple exponential backoff
  749.  * algorithm to reduce unnecessary bus traffic.  The initial delay is selected from
  750.  * the low-order bits of the cycle counter (a cheap "randomizer").  I'm sure this
  751.  * could use additional tuning, especially on systems with a large number of CPUs.
  752.  * Also, I think the maximum delay should be made a function of the number of CPUs in
  753.  * the system. --davidm 00/08/05
  754.  *
  755.  * WARNING: This is not a normal procedure.  It gets called from C code without
  756.  * the compiler knowing about it.  Thus, we must not use any scratch registers
  757.  * beyond those that were declared "clobbered" at the call-site (see spin_lock()
  758.  * macro).  We may not even use the stacked registers, because that could overwrite
  759.  * output registers.  Similarly, we can't use the scratch stack area as it may be
  760.  * in use, too.
  761.  *
  762.  * Inputs:
  763.  * ar.ccv = 0 (and available for use)
  764.  * r28 = available for use
  765.  * r29 = available for use
  766.  * r30 = non-zero (and available for use)
  767.  * r31 = address of lock we're trying to acquire
  768.  * p15 = available for use
  769.  */
  771. # define delay r28
  772. # define timeout r29
  773. # define tmp r30
  775. GLOBAL_ENTRY(ia64_spinlock_contention)
  776. mov tmp=ar.itc
  777. ;;
  778. and delay=0x3f,tmp
  779. ;;
  781. .retry: add timeout=tmp,delay
  782. shl delay=delay,1
  783. ;;
  784. dep delay=delay,r0,0,13 // limit delay to 8192 cycles
  785. ;;
  786. // delay a little...
  787. .wait: sub tmp=tmp,timeout
  788. or delay=0xf,delay // make sure delay is non-zero (otherwise we get stuck with 0)
  789. ;;
  790. cmp.lt p15,p0=tmp,r0
  791. mov tmp=ar.itc
  792. (p15) br.cond.sptk .wait
  793. ;;
  794. ld4 tmp=[r31]
  795. ;;
  796. cmp.ne p15,p0=tmp,r0
  797. mov tmp=ar.itc
  798. (p15) br.cond.sptk .retry // lock is still busy
  799. ;;
  800. // try acquiring lock (we know ar.ccv is still zero!):
  801. mov tmp=1
  802. ;;
  803. cmpxchg4.acq tmp=[r31],tmp,ar.ccv
  804. ;;
  805. cmp.eq p15,p0=tmp,r0
  807. mov tmp=ar.itc
  808. (p15) br.ret.sptk.many b7 // got lock -> return
  809. br .retry // still no luck, retry
  811. END(ia64_spinlock_contention)
  813. #endif