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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
head.S
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：17k
源码类别：

嵌入式Linux

开发平台：

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. .previous
  185. alloc r2=ar.pfs,0,0,2,0
  186. movl out0=alive_msg
  187. ;;
  188. br.call.sptk.many rp=early_printk
  189. 1: // force new bundle
  190. #endif /* CONFIG_IA64_EARLY_PRINTK */
  192. #ifdef CONFIG_SMP
  193. (isAP) br.call.sptk.many rp=start_secondary
  194. .ret0:
  195. (isAP) br.cond.sptk self
  196. #endif
  198. // This is executed by the bootstrap processor (bsp) only:
  200. #ifdef CONFIG_IA64_FW_EMU
  201. // initialize PAL & SAL emulator:
  202. br.call.sptk.many rp=sys_fw_init
  203. .ret1:
  204. #endif
  205. br.call.sptk.many rp=start_kernel
  206. .ret2: addl r3=@ltoff(halt_msg),gp
  207. ;;
  208. alloc r2=ar.pfs,8,0,2,0
  209. ;;
  210. ld8 out0=[r3]
  211. br.call.sptk.many b0=console_print
  212. self: br.sptk.many self // endless loop
  213. END(_start)
  215. GLOBAL_ENTRY(ia64_save_debug_regs)
  216. alloc r16=ar.pfs,1,0,0,0
  217. mov r20=ar.lc // preserve ar.lc
  218. mov ar.lc=IA64_NUM_DBG_REGS-1
  219. mov r18=0
  220. add r19=IA64_NUM_DBG_REGS*8,in0
  221. ;;
  222. 1: mov r16=dbr[r18]
  223. #ifdef CONFIG_ITANIUM
  224. ;;
  225. srlz.d
  226. #endif
  227. mov r17=ibr[r18]
  228. add r18=1,r18
  229. ;;
  230. st8.nta [in0]=r16,8
  231. st8.nta [r19]=r17,8
  232. br.cloop.sptk.many 1b
  233. ;;
  234. mov ar.lc=r20 // restore ar.lc
  235. br.ret.sptk.many rp
  236. END(ia64_save_debug_regs)
  238. GLOBAL_ENTRY(ia64_load_debug_regs)
  239. alloc r16=ar.pfs,1,0,0,0
  240. lfetch.nta [in0]
  241. mov r20=ar.lc // preserve ar.lc
  242. add r19=IA64_NUM_DBG_REGS*8,in0
  243. mov ar.lc=IA64_NUM_DBG_REGS-1
  244. mov r18=-1
  245. ;;
  246. 1: ld8.nta r16=[in0],8
  247. ld8.nta r17=[r19],8
  248. add r18=1,r18
  249. ;;
  250. mov dbr[r18]=r16
  251. #ifdef CONFIG_ITANIUM
  252. ;;
  253. srlz.d // Errata 132 (NoFix status)
  254. #endif
  255. mov ibr[r18]=r17
  256. br.cloop.sptk.many 1b
  257. ;;
  258. mov ar.lc=r20 // restore ar.lc
  259. br.ret.sptk.many rp
  260. END(ia64_load_debug_regs)
  262. GLOBAL_ENTRY(__ia64_save_fpu)
  263. alloc r2=ar.pfs,1,0,0,0
  264. adds r3=16,in0
  265. ;;
  266. stf.spill.nta [in0]=f32,32
  267. stf.spill.nta [ r3]=f33,32
  268. ;;
  269. stf.spill.nta [in0]=f34,32
  270. stf.spill.nta [ r3]=f35,32
  271. ;;
  272. stf.spill.nta [in0]=f36,32
  273. stf.spill.nta [ r3]=f37,32
  274. ;;
  275. stf.spill.nta [in0]=f38,32
  276. stf.spill.nta [ r3]=f39,32
  277. ;;
  278. stf.spill.nta [in0]=f40,32
  279. stf.spill.nta [ r3]=f41,32
  280. ;;
  281. stf.spill.nta [in0]=f42,32
  282. stf.spill.nta [ r3]=f43,32
  283. ;;
  284. stf.spill.nta [in0]=f44,32
  285. stf.spill.nta [ r3]=f45,32
  286. ;;
  287. stf.spill.nta [in0]=f46,32
  288. stf.spill.nta [ r3]=f47,32
  289. ;;
  290. stf.spill.nta [in0]=f48,32
  291. stf.spill.nta [ r3]=f49,32
  292. ;;
  293. stf.spill.nta [in0]=f50,32
  294. stf.spill.nta [ r3]=f51,32
  295. ;;
  296. stf.spill.nta [in0]=f52,32
  297. stf.spill.nta [ r3]=f53,32
  298. ;;
  299. stf.spill.nta [in0]=f54,32
  300. stf.spill.nta [ r3]=f55,32
  301. ;;
  302. stf.spill.nta [in0]=f56,32
  303. stf.spill.nta [ r3]=f57,32
  304. ;;
  305. stf.spill.nta [in0]=f58,32
  306. stf.spill.nta [ r3]=f59,32
  307. ;;
  308. stf.spill.nta [in0]=f60,32
  309. stf.spill.nta [ r3]=f61,32
  310. ;;
  311. stf.spill.nta [in0]=f62,32
  312. stf.spill.nta [ r3]=f63,32
  313. ;;
  314. stf.spill.nta [in0]=f64,32
  315. stf.spill.nta [ r3]=f65,32
  316. ;;
  317. stf.spill.nta [in0]=f66,32
  318. stf.spill.nta [ r3]=f67,32
  319. ;;
  320. stf.spill.nta [in0]=f68,32
  321. stf.spill.nta [ r3]=f69,32
  322. ;;
  323. stf.spill.nta [in0]=f70,32
  324. stf.spill.nta [ r3]=f71,32
  325. ;;
  326. stf.spill.nta [in0]=f72,32
  327. stf.spill.nta [ r3]=f73,32
  328. ;;
  329. stf.spill.nta [in0]=f74,32
  330. stf.spill.nta [ r3]=f75,32
  331. ;;
  332. stf.spill.nta [in0]=f76,32
  333. stf.spill.nta [ r3]=f77,32
  334. ;;
  335. stf.spill.nta [in0]=f78,32
  336. stf.spill.nta [ r3]=f79,32
  337. ;;
  338. stf.spill.nta [in0]=f80,32
  339. stf.spill.nta [ r3]=f81,32
  340. ;;
  341. stf.spill.nta [in0]=f82,32
  342. stf.spill.nta [ r3]=f83,32
  343. ;;
  344. stf.spill.nta [in0]=f84,32
  345. stf.spill.nta [ r3]=f85,32
  346. ;;
  347. stf.spill.nta [in0]=f86,32
  348. stf.spill.nta [ r3]=f87,32
  349. ;;
  350. stf.spill.nta [in0]=f88,32
  351. stf.spill.nta [ r3]=f89,32
  352. ;;
  353. stf.spill.nta [in0]=f90,32
  354. stf.spill.nta [ r3]=f91,32
  355. ;;
  356. stf.spill.nta [in0]=f92,32
  357. stf.spill.nta [ r3]=f93,32
  358. ;;
  359. stf.spill.nta [in0]=f94,32
  360. stf.spill.nta [ r3]=f95,32
  361. ;;
  362. stf.spill.nta [in0]=f96,32
  363. stf.spill.nta [ r3]=f97,32
  364. ;;
  365. stf.spill.nta [in0]=f98,32
  366. stf.spill.nta [ r3]=f99,32
  367. ;;
  368. stf.spill.nta [in0]=f100,32
  369. stf.spill.nta [ r3]=f101,32
  370. ;;
  371. stf.spill.nta [in0]=f102,32
  372. stf.spill.nta [ r3]=f103,32
  373. ;;
  374. stf.spill.nta [in0]=f104,32
  375. stf.spill.nta [ r3]=f105,32
  376. ;;
  377. stf.spill.nta [in0]=f106,32
  378. stf.spill.nta [ r3]=f107,32
  379. ;;
  380. stf.spill.nta [in0]=f108,32
  381. stf.spill.nta [ r3]=f109,32
  382. ;;
  383. stf.spill.nta [in0]=f110,32
  384. stf.spill.nta [ r3]=f111,32
  385. ;;
  386. stf.spill.nta [in0]=f112,32
  387. stf.spill.nta [ r3]=f113,32
  388. ;;
  389. stf.spill.nta [in0]=f114,32
  390. stf.spill.nta [ r3]=f115,32
  391. ;;
  392. stf.spill.nta [in0]=f116,32
  393. stf.spill.nta [ r3]=f117,32
  394. ;;
  395. stf.spill.nta [in0]=f118,32
  396. stf.spill.nta [ r3]=f119,32
  397. ;;
  398. stf.spill.nta [in0]=f120,32
  399. stf.spill.nta [ r3]=f121,32
  400. ;;
  401. stf.spill.nta [in0]=f122,32
  402. stf.spill.nta [ r3]=f123,32
  403. ;;
  404. stf.spill.nta [in0]=f124,32
  405. stf.spill.nta [ r3]=f125,32
  406. ;;
  407. stf.spill.nta [in0]=f126,32
  408. stf.spill.nta [ r3]=f127,32
  409. br.ret.sptk.many rp
  410. END(__ia64_save_fpu)
  412. GLOBAL_ENTRY(__ia64_load_fpu)
  413. alloc r2=ar.pfs,1,0,0,0
  414. adds r3=16,in0
  415. ;;
  416. ldf.fill.nta f32=[in0],32
  417. ldf.fill.nta f33=[ r3],32
  418. ;;
  419. ldf.fill.nta f34=[in0],32
  420. ldf.fill.nta f35=[ r3],32
  421. ;;
  422. ldf.fill.nta f36=[in0],32
  423. ldf.fill.nta f37=[ r3],32
  424. ;;
  425. ldf.fill.nta f38=[in0],32
  426. ldf.fill.nta f39=[ r3],32
  427. ;;
  428. ldf.fill.nta f40=[in0],32
  429. ldf.fill.nta f41=[ r3],32
  430. ;;
  431. ldf.fill.nta f42=[in0],32
  432. ldf.fill.nta f43=[ r3],32
  433. ;;
  434. ldf.fill.nta f44=[in0],32
  435. ldf.fill.nta f45=[ r3],32
  436. ;;
  437. ldf.fill.nta f46=[in0],32
  438. ldf.fill.nta f47=[ r3],32
  439. ;;
  440. ldf.fill.nta f48=[in0],32
  441. ldf.fill.nta f49=[ r3],32
  442. ;;
  443. ldf.fill.nta f50=[in0],32
  444. ldf.fill.nta f51=[ r3],32
  445. ;;
  446. ldf.fill.nta f52=[in0],32
  447. ldf.fill.nta f53=[ r3],32
  448. ;;
  449. ldf.fill.nta f54=[in0],32
  450. ldf.fill.nta f55=[ r3],32
  451. ;;
  452. ldf.fill.nta f56=[in0],32
  453. ldf.fill.nta f57=[ r3],32
  454. ;;
  455. ldf.fill.nta f58=[in0],32
  456. ldf.fill.nta f59=[ r3],32
  457. ;;
  458. ldf.fill.nta f60=[in0],32
  459. ldf.fill.nta f61=[ r3],32
  460. ;;
  461. ldf.fill.nta f62=[in0],32
  462. ldf.fill.nta f63=[ r3],32
  463. ;;
  464. ldf.fill.nta f64=[in0],32
  465. ldf.fill.nta f65=[ r3],32
  466. ;;
  467. ldf.fill.nta f66=[in0],32
  468. ldf.fill.nta f67=[ r3],32
  469. ;;
  470. ldf.fill.nta f68=[in0],32
  471. ldf.fill.nta f69=[ r3],32
  472. ;;
  473. ldf.fill.nta f70=[in0],32
  474. ldf.fill.nta f71=[ r3],32
  475. ;;
  476. ldf.fill.nta f72=[in0],32
  477. ldf.fill.nta f73=[ r3],32
  478. ;;
  479. ldf.fill.nta f74=[in0],32
  480. ldf.fill.nta f75=[ r3],32
  481. ;;
  482. ldf.fill.nta f76=[in0],32
  483. ldf.fill.nta f77=[ r3],32
  484. ;;
  485. ldf.fill.nta f78=[in0],32
  486. ldf.fill.nta f79=[ r3],32
  487. ;;
  488. ldf.fill.nta f80=[in0],32
  489. ldf.fill.nta f81=[ r3],32
  490. ;;
  491. ldf.fill.nta f82=[in0],32
  492. ldf.fill.nta f83=[ r3],32
  493. ;;
  494. ldf.fill.nta f84=[in0],32
  495. ldf.fill.nta f85=[ r3],32
  496. ;;
  497. ldf.fill.nta f86=[in0],32
  498. ldf.fill.nta f87=[ r3],32
  499. ;;
  500. ldf.fill.nta f88=[in0],32
  501. ldf.fill.nta f89=[ r3],32
  502. ;;
  503. ldf.fill.nta f90=[in0],32
  504. ldf.fill.nta f91=[ r3],32
  505. ;;
  506. ldf.fill.nta f92=[in0],32
  507. ldf.fill.nta f93=[ r3],32
  508. ;;
  509. ldf.fill.nta f94=[in0],32
  510. ldf.fill.nta f95=[ r3],32
  511. ;;
  512. ldf.fill.nta f96=[in0],32
  513. ldf.fill.nta f97=[ r3],32
  514. ;;
  515. ldf.fill.nta f98=[in0],32
  516. ldf.fill.nta f99=[ r3],32
  517. ;;
  518. ldf.fill.nta f100=[in0],32
  519. ldf.fill.nta f101=[ r3],32
  520. ;;
  521. ldf.fill.nta f102=[in0],32
  522. ldf.fill.nta f103=[ r3],32
  523. ;;
  524. ldf.fill.nta f104=[in0],32
  525. ldf.fill.nta f105=[ r3],32
  526. ;;
  527. ldf.fill.nta f106=[in0],32
  528. ldf.fill.nta f107=[ r3],32
  529. ;;
  530. ldf.fill.nta f108=[in0],32
  531. ldf.fill.nta f109=[ r3],32
  532. ;;
  533. ldf.fill.nta f110=[in0],32
  534. ldf.fill.nta f111=[ r3],32
  535. ;;
  536. ldf.fill.nta f112=[in0],32
  537. ldf.fill.nta f113=[ r3],32
  538. ;;
  539. ldf.fill.nta f114=[in0],32
  540. ldf.fill.nta f115=[ r3],32
  541. ;;
  542. ldf.fill.nta f116=[in0],32
  543. ldf.fill.nta f117=[ r3],32
  544. ;;
  545. ldf.fill.nta f118=[in0],32
  546. ldf.fill.nta f119=[ r3],32
  547. ;;
  548. ldf.fill.nta f120=[in0],32
  549. ldf.fill.nta f121=[ r3],32
  550. ;;
  551. ldf.fill.nta f122=[in0],32
  552. ldf.fill.nta f123=[ r3],32
  553. ;;
  554. ldf.fill.nta f124=[in0],32
  555. ldf.fill.nta f125=[ r3],32
  556. ;;
  557. ldf.fill.nta f126=[in0],32
  558. ldf.fill.nta f127=[ r3],32
  559. br.ret.sptk.many rp
  560. END(__ia64_load_fpu)
  562. GLOBAL_ENTRY(__ia64_init_fpu)
  563. alloc r2=ar.pfs,0,0,0,0
  564. stf.spill [sp]=f0
  565. mov      f32=f0
  566. ;;
  567. ldf.fill f33=[sp]
  568. ldf.fill f34=[sp]
  569. mov      f35=f0
  570. ;;
  571. ldf.fill f36=[sp]
  572. ldf.fill f37=[sp]
  573. mov      f38=f0
  574. ;;
  575. ldf.fill f39=[sp]
  576. ldf.fill f40=[sp]
  577. mov      f41=f0
  578. ;;
  579. ldf.fill f42=[sp]
  580. ldf.fill f43=[sp]
  581. mov      f44=f0
  582. ;;
  583. ldf.fill f45=[sp]
  584. ldf.fill f46=[sp]
  585. mov      f47=f0
  586. ;;
  587. ldf.fill f48=[sp]
  588. ldf.fill f49=[sp]
  589. mov      f50=f0
  590. ;;
  591. ldf.fill f51=[sp]
  592. ldf.fill f52=[sp]
  593. mov      f53=f0
  594. ;;
  595. ldf.fill f54=[sp]
  596. ldf.fill f55=[sp]
  597. mov      f56=f0
  598. ;;
  599. ldf.fill f57=[sp]
  600. ldf.fill f58=[sp]
  601. mov      f59=f0
  602. ;;
  603. ldf.fill f60=[sp]
  604. ldf.fill f61=[sp]
  605. mov      f62=f0
  606. ;;
  607. ldf.fill f63=[sp]
  608. ldf.fill f64=[sp]
  609. mov      f65=f0
  610. ;;
  611. ldf.fill f66=[sp]
  612. ldf.fill f67=[sp]
  613. mov      f68=f0
  614. ;;
  615. ldf.fill f69=[sp]
  616. ldf.fill f70=[sp]
  617. mov      f71=f0
  618. ;;
  619. ldf.fill f72=[sp]
  620. ldf.fill f73=[sp]
  621. mov      f74=f0
  622. ;;
  623. ldf.fill f75=[sp]
  624. ldf.fill f76=[sp]
  625. mov      f77=f0
  626. ;;
  627. ldf.fill f78=[sp]
  628. ldf.fill f79=[sp]
  629. mov      f80=f0
  630. ;;
  631. ldf.fill f81=[sp]
  632. ldf.fill f82=[sp]
  633. mov      f83=f0
  634. ;;
  635. ldf.fill f84=[sp]
  636. ldf.fill f85=[sp]
  637. mov      f86=f0
  638. ;;
  639. ldf.fill f87=[sp]
  640. ldf.fill f88=[sp]
  641. mov      f89=f0
  642. ;;
  643. ldf.fill f90=[sp]
  644. ldf.fill f91=[sp]
  645. mov      f92=f0
  646. ;;
  647. ldf.fill f93=[sp]
  648. ldf.fill f94=[sp]
  649. mov      f95=f0
  650. ;;
  651. ldf.fill f96=[sp]
  652. ldf.fill f97=[sp]
  653. mov      f98=f0
  654. ;;
  655. ldf.fill f99=[sp]
  656. ldf.fill f100=[sp]
  657. mov      f101=f0
  658. ;;
  659. ldf.fill f102=[sp]
  660. ldf.fill f103=[sp]
  661. mov      f104=f0
  662. ;;
  663. ldf.fill f105=[sp]
  664. ldf.fill f106=[sp]
  665. mov      f107=f0
  666. ;;
  667. ldf.fill f108=[sp]
  668. ldf.fill f109=[sp]
  669. mov      f110=f0
  670. ;;
  671. ldf.fill f111=[sp]
  672. ldf.fill f112=[sp]
  673. mov      f113=f0
  674. ;;
  675. ldf.fill f114=[sp]
  676. ldf.fill f115=[sp]
  677. mov      f116=f0
  678. ;;
  679. ldf.fill f117=[sp]
  680. ldf.fill f118=[sp]
  681. mov      f119=f0
  682. ;;
  683. ldf.fill f120=[sp]
  684. ldf.fill f121=[sp]
  685. mov      f122=f0
  686. ;;
  687. ldf.fill f123=[sp]
  688. ldf.fill f124=[sp]
  689. mov      f125=f0
  690. ;;
  691. ldf.fill f126=[sp]
  692. mov      f127=f0
  693. br.ret.sptk.many rp
  694. END(__ia64_init_fpu)
  696. /*
  697.  * Switch execution mode from virtual to physical or vice versa.
  698.  *
  699.  * Inputs:
  700.  * r16 = new psr to establish
  701.  *
  702.  * Note: RSE must already be in enforced lazy mode
  703.  */
  704. GLOBAL_ENTRY(ia64_switch_mode)
  705.  {
  706. alloc r2=ar.pfs,0,0,0,0
  707. rsm psr.i | psr.ic // disable interrupts and interrupt collection
  708. mov r15=ip
  709.  }
  710. ;;
  711.  {
  712. flushrs // must be first insn in group
  713. srlz.i
  714. shr.u r19=r15,61 // r19 <- top 3 bits of current IP
  715.  }
  716. ;;
  717. mov cr.ipsr=r16 // set new PSR
  718. add r3=1f-ia64_switch_mode,r15
  719. xor r15=0x7,r19 // flip the region bits
  721. mov r17=ar.bsp
  722. mov r14=rp // get return address into a general register
  724. // switch RSE backing store:
  725. ;;
  726. dep r17=r15,r17,61,3 // make ar.bsp physical or virtual
  727. mov r18=ar.rnat // save ar.rnat
  728. ;;
  729. mov ar.bspstore=r17 // this steps on ar.rnat
  730. dep r3=r15,r3,61,3 // make rfi return address physical or virtual
  731. ;;
  732. mov cr.iip=r3
  733. mov cr.ifs=r0
  734. dep sp=r15,sp,61,3 // make stack pointer physical or virtual
  735. ;;
  736. mov ar.rnat=r18 // restore ar.rnat
  737. dep r14=r15,r14,61,3 // make function return address physical or virtual
  738. rfi // must be last insn in group
  739. ;;
  740. 1: mov rp=r14
  741. br.ret.sptk.many rp
  742. END(ia64_switch_mode)
  744. #ifdef CONFIG_IA64_BRL_EMU
  746. /*
  747.  *  Assembly routines used by brl_emu.c to set preserved register state.
  748.  */
  750. #define SET_REG(reg)
  751.  GLOBAL_ENTRY(ia64_set_##reg);
  752. alloc r16=ar.pfs,1,0,0,0;
  753. mov reg=r32;
  754. ;;
  755. br.ret.sptk.many rp;
  756.  END(ia64_set_##reg)
  758. SET_REG(b1);
  759. SET_REG(b2);
  760. SET_REG(b3);
  761. SET_REG(b4);
  762. SET_REG(b5);
  764. #endif /* CONFIG_IA64_BRL_EMU */
  766. #ifdef CONFIG_SMP
  768. /*
  769.  * This routine handles spinlock contention.  It uses a simple exponential backoff
  770.  * algorithm to reduce unnecessary bus traffic.  The initial delay is selected from
  771.  * the low-order bits of the cycle counter (a cheap "randomizer").  I'm sure this
  772.  * could use additional tuning, especially on systems with a large number of CPUs.
  773.  * Also, I think the maximum delay should be made a function of the number of CPUs in
  774.  * the system. --davidm 00/08/05
  775.  *
  776.  * WARNING: This is not a normal procedure.  It gets called from C code without
  777.  * the compiler knowing about it.  Thus, we must not use any scratch registers
  778.  * beyond those that were declared "clobbered" at the call-site (see spin_lock()
  779.  * macro).  We may not even use the stacked registers, because that could overwrite
  780.  * output registers.  Similarly, we can't use the scratch stack area as it may be
  781.  * in use, too.
  782.  *
  783.  * Inputs:
  784.  * ar.ccv = 0 (and available for use)
  785.  * r28 = available for use
  786.  * r29 = available for use
  787.  * r30 = non-zero (and available for use)
  788.  * r31 = address of lock we're trying to acquire
  789.  * p15 = available for use
  790.  */
  792. # define delay r28
  793. # define timeout r29
  794. # define tmp r30
  796. GLOBAL_ENTRY(ia64_spinlock_contention)
  797. mov tmp=ar.itc
  798. ;;
  799. and delay=0x3f,tmp
  800. ;;
  802. .retry: add timeout=tmp,delay
  803. shl delay=delay,1
  804. ;;
  805. dep delay=delay,r0,0,13 // limit delay to 8192 cycles
  806. ;;
  807. // delay a little...
  808. .wait: sub tmp=tmp,timeout
  809. or delay=0xf,delay // make sure delay is non-zero (otherwise we get stuck with 0)
  810. ;;
  811. cmp.lt p15,p0=tmp,r0
  812. mov tmp=ar.itc
  813. (p15) br.cond.sptk .wait
  814. ;;
  815. ld4 tmp=[r31]
  816. ;;
  817. cmp.ne p15,p0=tmp,r0
  818. mov tmp=ar.itc
  819. (p15) br.cond.sptk .retry // lock is still busy
  820. ;;
  821. // try acquiring lock (we know ar.ccv is still zero!):
  822. mov tmp=1
  823. ;;
  824. cmpxchg4.acq tmp=[r31],tmp,ar.ccv
  825. ;;
  826. cmp.eq p15,p0=tmp,r0
  828. mov tmp=ar.itc
  829. (p15) br.ret.sptk.many b7 // got lock -> return
  830. br .retry // still no luck, retry
  832. END(ia64_spinlock_contention)
  834. #endif