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

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

Linux/Unix编程

开发平台：

Unix_Linux

hwc_rw.c：源码内容
  1. /*
  2.  *  drivers/s390/char/hwc_rw.c
  3.  *     driver: reading from and writing to system console on S/390 via HWC
  4.  *
  5.  *  S390 version
  6.  *    Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
  7.  *    Author(s): Martin Peschke <mpeschke@de.ibm.com>
  8.  *
  9.  * 
  10.  *
  11.  * 
  12.  * 
  13.  * 
  14.  */
  16. #include <linux/kernel.h>
  17. #include <linux/string.h>
  18. #include <linux/errno.h>
  19. #include <linux/ctype.h>
  20. #include <linux/mm.h>
  21. #include <linux/timer.h>
  22. #include <linux/bootmem.h>
  23. #include <linux/module.h>
  25. #include <asm/ebcdic.h>
  26. #include <asm/uaccess.h>
  27. #include <asm/types.h>
  28. #include <asm/bitops.h>
  29. #include <asm/setup.h>
  30. #include <asm/page.h>
  31. #include <asm/s390_ext.h>
  32. #include <asm/irq.h>
  34. #ifndef MIN
  35. #define MIN(a,b) (((a<b) ? a : b))
  36. #endif
  38. extern void ctrl_alt_del (void);
  40. #define HWC_RW_PRINT_HEADER "hwc low level driver: "
  42. #define  USE_VM_DETECTION
  44. #define  DEFAULT_CASE_DELIMITER '%'
  46. #undef DUMP_HWC_INIT_ERROR
  48. #undef DUMP_HWC_WRITE_ERROR
  50. #undef DUMP_HWC_WRITE_LIST_ERROR
  52. #undef DUMP_HWC_READ_ERROR
  54. #undef DUMP_HWCB_INPUT
  56. #undef BUFFER_STRESS_TEST
  58. typedef struct {
  59. unsigned char *next;
  60. unsigned short int mto_char_sum;
  61. unsigned char mto_number;
  62. unsigned char times_lost;
  63. unsigned short int mto_number_lost;
  64. unsigned long int mto_char_sum_lost;
  65. } __attribute__ ((packed)) 
  67. hwcb_list_t;
  69. #define MAX_HWCB_ROOM (PAGE_SIZE - sizeof(hwcb_list_t))
  71. #define MAX_MESSAGE_SIZE (MAX_HWCB_ROOM - sizeof(write_hwcb_t))
  73. #define BUF_HWCB hwc_data.hwcb_list_tail
  74. #define OUT_HWCB hwc_data.hwcb_list_head
  75. #define ALL_HWCB_MTO hwc_data.mto_number
  76. #define ALL_HWCB_CHAR hwc_data.mto_char_sum
  78. #define _LIST(hwcb) ((hwcb_list_t*)(&(hwcb)[PAGE_SIZE-sizeof(hwcb_list_t)]))
  80. #define _HWCB_CHAR(hwcb) (_LIST(hwcb)->mto_char_sum)
  82. #define _HWCB_MTO(hwcb) (_LIST(hwcb)->mto_number)
  84. #define _HWCB_CHAR_LOST(hwcb) (_LIST(hwcb)->mto_char_sum_lost)
  86. #define _HWCB_MTO_LOST(hwcb) (_LIST(hwcb)->mto_number_lost)
  88. #define _HWCB_TIMES_LOST(hwcb) (_LIST(hwcb)->times_lost)
  90. #define _HWCB_NEXT(hwcb) (_LIST(hwcb)->next)
  92. #define BUF_HWCB_CHAR _HWCB_CHAR(BUF_HWCB)
  94. #define BUF_HWCB_MTO _HWCB_MTO(BUF_HWCB)
  96. #define BUF_HWCB_NEXT _HWCB_NEXT(BUF_HWCB)
  98. #define OUT_HWCB_CHAR _HWCB_CHAR(OUT_HWCB)
  100. #define OUT_HWCB_MTO _HWCB_MTO(OUT_HWCB)
  102. #define OUT_HWCB_NEXT _HWCB_NEXT(OUT_HWCB)
  104. #define BUF_HWCB_CHAR_LOST _HWCB_CHAR_LOST(BUF_HWCB)
  106. #define BUF_HWCB_MTO_LOST _HWCB_MTO_LOST(BUF_HWCB)
  108. #define OUT_HWCB_CHAR_LOST _HWCB_CHAR_LOST(OUT_HWCB)
  110. #define OUT_HWCB_MTO_LOST _HWCB_MTO_LOST(OUT_HWCB)
  112. #define BUF_HWCB_TIMES_LOST _HWCB_TIMES_LOST(BUF_HWCB)
  114. #include  "hwc.h"
  116. #define __HWC_RW_C__
  117. #include "hwc_rw.h"
  118. #undef __HWC_RW_C__
  120. static unsigned char _obuf[MAX_HWCB_ROOM];
  122. static unsigned char
  123.  _page[PAGE_SIZE] __attribute__ ((aligned (PAGE_SIZE)));
  125. typedef unsigned long kmem_pages_t;
  127. #define MAX_KMEM_PAGES (sizeof(kmem_pages_t) << 3)
  129. #define HWC_WTIMER_RUNS 1
  130. #define HWC_FLUSH 2
  131. #define HWC_INIT 4
  132. #define HWC_BROKEN 8
  133. #define HWC_INTERRUPT 16
  134. #define HWC_PTIMER_RUNS 32
  136. static struct {
  138. hwc_ioctls_t ioctls;
  140. hwc_ioctls_t init_ioctls;
  142. unsigned char *hwcb_list_head;
  144. unsigned char *hwcb_list_tail;
  146. unsigned short int mto_number;
  148. unsigned int mto_char_sum;
  150. unsigned char hwcb_count;
  152. unsigned long kmem_start;
  154. unsigned long kmem_end;
  156. kmem_pages_t kmem_pages;
  158. unsigned char *obuf;
  160. unsigned short int obuf_cursor;
  162. unsigned short int obuf_count;
  164. unsigned short int obuf_start;
  166. unsigned char *page;
  168. u32 current_servc;
  170. unsigned char *current_hwcb;
  172. unsigned char write_nonprio:1;
  173. unsigned char write_prio:1;
  174. unsigned char read_nonprio:1;
  175. unsigned char read_prio:1;
  176. unsigned char read_statechange:1;
  177. unsigned char sig_quiesce:1;
  179. unsigned char flags;
  181. hwc_high_level_calls_t *calls;
  183. hwc_request_t *request;
  185. spinlock_t lock;
  187. struct timer_list write_timer;
  189. struct timer_list poll_timer;
  190. } hwc_data =
  191. {
  192. {
  193. },
  194. {
  195. 8,
  196.     0,
  197.     80,
  198.     1,
  199.     MAX_KMEM_PAGES,
  200.     MAX_KMEM_PAGES,
  202.     0,
  204.     0x6c
  206. },
  207.     NULL,
  208.     NULL,
  209.     0,
  210.     0,
  211.     0,
  212.     0,
  213.     0,
  214.     0,
  215.     _obuf,
  216.     0,
  217.     0,
  218.     0,
  219.     _page,
  220.     0,
  221.     NULL,
  222.     0,
  223.     0,
  224.     0,
  225.     0,
  226.     0,
  227.     0,
  228.     0,
  229.     NULL,
  230.     NULL
  232. };
  234. static unsigned long cr0 __attribute__ ((aligned (8)));
  235. static unsigned long cr0_save __attribute__ ((aligned (8)));
  236. static unsigned char psw_mask __attribute__ ((aligned (8)));
  238. static ext_int_info_t ext_int_info_hwc;
  240. #define DELAYED_WRITE 0
  241. #define IMMEDIATE_WRITE 1
  243. static signed int do_hwc_write (int from_user, unsigned char *,
  244. unsigned int,
  245. unsigned char);
  247. unsigned char hwc_ip_buf[512];
  249. static asmlinkage int 
  250. internal_print (char write_time, char *fmt,...)
  251. {
  252. va_list args;
  253. int i;
  255. va_start (args, fmt);
  256. i = vsprintf (hwc_ip_buf, fmt, args);
  257. va_end (args);
  258. return do_hwc_write (0, hwc_ip_buf, i, write_time);
  259. }
  261. int 
  262. hwc_printk (const char *fmt,...)
  263. {
  264. va_list args;
  265. int i;
  266. unsigned long flags;
  267. int retval;
  269. spin_lock_irqsave (&hwc_data.lock, flags);
  271. i = vsprintf (hwc_ip_buf, fmt, args);
  272. va_end (args);
  273. retval = do_hwc_write (0, hwc_ip_buf, i, IMMEDIATE_WRITE);
  275. spin_unlock_irqrestore (&hwc_data.lock, flags);
  277. return retval;
  278. }
  280. #ifdef DUMP_HWCB_INPUT
  282. static void 
  283. dump_storage_area (unsigned char *area, unsigned short int count)
  284. {
  285. unsigned short int index;
  286. ioctl_nl_t old_final_nl;
  288. if (!area || !count)
  289. return;
  291. old_final_nl = hwc_data.ioctls.final_nl;
  292. hwc_data.ioctls.final_nl = 1;
  294. internal_print (DELAYED_WRITE, "n%8x   ", area);
  296. for (index = 0; index < count; index++) {
  298. if (area[index] <= 0xF)
  299. internal_print (DELAYED_WRITE, "0%x", area[index]);
  300. else
  301. internal_print (DELAYED_WRITE, "%x", area[index]);
  303. if ((index & 0xF) == 0xF)
  304. internal_print (DELAYED_WRITE, "n%8x   ",
  305. &area[index + 1]);
  306. else if ((index & 3) == 3)
  307. internal_print (DELAYED_WRITE, " ");
  308. }
  310. internal_print (IMMEDIATE_WRITE, "n");
  312. hwc_data.ioctls.final_nl = old_final_nl;
  313. }
  314. #endif
  316. static inline u32 
  317. service_call (
  318.      u32 hwc_command_word,
  319.      unsigned char hwcb[])
  320. {
  321. unsigned int condition_code = 1;
  323. __asm__ __volatile__ ("L 1, 0(%0) nt"
  324.       "LRA 2, 0(%1) nt"
  325.       ".long 0xB2200012 nt"
  326.       :
  327.       :"a" (&hwc_command_word), "a" (hwcb)
  328.       :"1", "2", "memory");
  330. __asm__ __volatile__ ("IPM %0 nt"
  331.       "SRL %0, 28 nt"
  332.       :"=r" (condition_code));
  334. return condition_code;
  335. }
  337. static inline unsigned long 
  338. hwc_ext_int_param (void)
  339. {
  340. u32 param;
  342. __asm__ __volatile__ ("L %0,128nt"
  343.       :"=r" (param));
  345. return (unsigned long) param;
  346. }
  348. static int 
  349. prepare_write_hwcb (void)
  350. {
  351. write_hwcb_t *hwcb;
  353. if (!BUF_HWCB)
  354. return -ENOMEM;
  356. BUF_HWCB_MTO = 0;
  357. BUF_HWCB_CHAR = 0;
  359. hwcb = (write_hwcb_t *) BUF_HWCB;
  361. memcpy (hwcb, &write_hwcb_template, sizeof (write_hwcb_t));
  363. return 0;
  364. }
  366. static int 
  367. sane_write_hwcb (void)
  368. {
  369. unsigned short int lost_msg;
  370. unsigned int lost_char;
  371. unsigned char lost_hwcb;
  372. unsigned char *bad_addr;
  373. unsigned long page;
  374. int page_nr;
  376. if (!OUT_HWCB)
  377. return -ENOMEM;
  379. if ((unsigned long) OUT_HWCB & 0xFFF) {
  381. bad_addr = OUT_HWCB;
  383. #ifdef DUMP_HWC_WRITE_LIST_ERROR
  384. __asm__ ("LHI 1,0xe30nt"
  385.  "LRA 2,0(%0) nt"
  386.  "J .+0 nt"
  387.       :
  388.       :  "a" (bad_addr)
  389.       :  "1", "2");
  390. #endif
  392. hwc_data.kmem_pages = 0;
  393. if ((unsigned long) BUF_HWCB & 0xFFF) {
  395. lost_hwcb = hwc_data.hwcb_count;
  396. lost_msg = ALL_HWCB_MTO;
  397. lost_char = ALL_HWCB_CHAR;
  399. OUT_HWCB = NULL;
  400. BUF_HWCB = NULL;
  401. ALL_HWCB_MTO = 0;
  402. ALL_HWCB_CHAR = 0;
  403. hwc_data.hwcb_count = 0;
  404. } else {
  406. lost_hwcb = hwc_data.hwcb_count - 1;
  407. lost_msg = ALL_HWCB_MTO - BUF_HWCB_MTO;
  408. lost_char = ALL_HWCB_CHAR - BUF_HWCB_CHAR;
  409. OUT_HWCB = BUF_HWCB;
  410. ALL_HWCB_MTO = BUF_HWCB_MTO;
  411. ALL_HWCB_CHAR = BUF_HWCB_CHAR;
  412. hwc_data.hwcb_count = 1;
  413. page = (unsigned long) BUF_HWCB;
  415. if (page >= hwc_data.kmem_start &&
  416.     page <= hwc_data.kmem_end) {
  418. page_nr = (int)
  419.     ((page - hwc_data.kmem_start) >> 12);
  420. set_bit (page_nr, &hwc_data.kmem_pages);
  421. }
  422. }
  424. internal_print (
  425.        DELAYED_WRITE,
  426.        HWC_RW_PRINT_HEADER
  427.        "found invalid HWCB at address 0x%lx. List corrupted. "
  428.    "Lost %i HWCBs with %i characters within up to %i "
  429.    "messages. Saved %i HWCB with last %i characters i"
  430.        "within up to %i messages.n",
  431.        (unsigned long) bad_addr,
  432.        lost_hwcb, lost_char, lost_msg,
  433.        hwc_data.hwcb_count,
  434.        ALL_HWCB_CHAR, ALL_HWCB_MTO);
  435. }
  436. return 0;
  437. }
  439. static int 
  440. reuse_write_hwcb (void)
  441. {
  442. int retval;
  444. if (hwc_data.hwcb_count < 2)
  445. #ifdef DUMP_HWC_WRITE_LIST_ERROR
  446. __asm__ ("LHI 1,0xe31nt"
  447.  "LRA 2,0(%0)nt"
  448.  "LRA 3,0(%1)nt"
  449.  "J .+0 nt"
  450.       :
  451.       :  "a" (BUF_HWCB), "a" (OUT_HWCB)
  452.       :  "1", "2", "3");
  453. #else
  454. return -EPERM;
  455. #endif
  457. if (hwc_data.current_hwcb == OUT_HWCB) {
  459. if (hwc_data.hwcb_count > 2) {
  461. BUF_HWCB_NEXT = OUT_HWCB_NEXT;
  463. BUF_HWCB = OUT_HWCB_NEXT;
  465. OUT_HWCB_NEXT = BUF_HWCB_NEXT;
  467. BUF_HWCB_NEXT = NULL;
  468. }
  469. } else {
  471. BUF_HWCB_NEXT = OUT_HWCB;
  473. BUF_HWCB = OUT_HWCB;
  475. OUT_HWCB = OUT_HWCB_NEXT;
  477. BUF_HWCB_NEXT = NULL;
  478. }
  480. BUF_HWCB_TIMES_LOST += 1;
  481. BUF_HWCB_CHAR_LOST += BUF_HWCB_CHAR;
  482. BUF_HWCB_MTO_LOST += BUF_HWCB_MTO;
  483. ALL_HWCB_MTO -= BUF_HWCB_MTO;
  484. ALL_HWCB_CHAR -= BUF_HWCB_CHAR;
  486. retval = prepare_write_hwcb ();
  488. if (hwc_data.hwcb_count == hwc_data.ioctls.max_hwcb)
  489. internal_print (
  490.        DELAYED_WRITE,
  491.        HWC_RW_PRINT_HEADER
  492.        "reached my own limit of "
  493.     "allowed buffer space for output (%i HWCBs = %li "
  494.   "bytes), skipped content of oldest HWCB %i time(s) "
  495.        "(%i lines = %i characters)n",
  496.        hwc_data.ioctls.max_hwcb,
  497.        hwc_data.ioctls.max_hwcb * PAGE_SIZE,
  498.        BUF_HWCB_TIMES_LOST,
  499.        BUF_HWCB_MTO_LOST,
  500.        BUF_HWCB_CHAR_LOST);
  501. else
  502. internal_print (
  503.        DELAYED_WRITE,
  504.        HWC_RW_PRINT_HEADER
  505.        "page allocation failed, "
  506.    "could not expand buffer for output (currently in "
  507.      "use: %i HWCBs = %li bytes), skipped content of "
  508. "oldest HWCB %i time(s) (%i lines = %i characters)n",
  509.        hwc_data.hwcb_count,
  510.        hwc_data.hwcb_count * PAGE_SIZE,
  511.        BUF_HWCB_TIMES_LOST,
  512.        BUF_HWCB_MTO_LOST,
  513.        BUF_HWCB_CHAR_LOST);
  515. return retval;
  516. }
  518. static int 
  519. allocate_write_hwcb (void)
  520. {
  521. unsigned char *page;
  522. int page_nr;
  524. if (hwc_data.hwcb_count == hwc_data.ioctls.max_hwcb)
  525. return -ENOMEM;
  527. page_nr = find_first_zero_bit (&hwc_data.kmem_pages, MAX_KMEM_PAGES);
  528. if (page_nr < hwc_data.ioctls.kmem_hwcb) {
  530. page = (unsigned char *)
  531.     (hwc_data.kmem_start + (page_nr << 12));
  532. set_bit (page_nr, &hwc_data.kmem_pages);
  533. } else
  534. page = (unsigned char *) __get_free_page (GFP_ATOMIC | GFP_DMA);
  536. if (!page)
  537. return -ENOMEM;
  539. if (!OUT_HWCB)
  540. OUT_HWCB = page;
  541. else
  542. BUF_HWCB_NEXT = page;
  544. BUF_HWCB = page;
  546. BUF_HWCB_NEXT = NULL;
  548. hwc_data.hwcb_count++;
  550. prepare_write_hwcb ();
  552. BUF_HWCB_TIMES_LOST = 0;
  553. BUF_HWCB_MTO_LOST = 0;
  554. BUF_HWCB_CHAR_LOST = 0;
  556. #ifdef BUFFER_STRESS_TEST
  558. internal_print (
  559.        DELAYED_WRITE,
  560.        "*** " HWC_RW_PRINT_HEADER
  561.     "page #%i at 0x%x for buffering allocated. ***n",
  562.        hwc_data.hwcb_count, page);
  564. #endif
  566. return 0;
  567. }
  569. static int 
  570. release_write_hwcb (void)
  571. {
  572. unsigned long page;
  573. int page_nr;
  575. if (!hwc_data.hwcb_count)
  576. return -ENODATA;
  578. if (hwc_data.hwcb_count == 1) {
  580. prepare_write_hwcb ();
  582. ALL_HWCB_CHAR = 0;
  583. ALL_HWCB_MTO = 0;
  584. BUF_HWCB_TIMES_LOST = 0;
  585. BUF_HWCB_MTO_LOST = 0;
  586. BUF_HWCB_CHAR_LOST = 0;
  587. } else {
  588. page = (unsigned long) OUT_HWCB;
  590. ALL_HWCB_MTO -= OUT_HWCB_MTO;
  591. ALL_HWCB_CHAR -= OUT_HWCB_CHAR;
  592. hwc_data.hwcb_count--;
  594. OUT_HWCB = OUT_HWCB_NEXT;
  596. if (page >= hwc_data.kmem_start &&
  597.     page <= hwc_data.kmem_end) {
  598. /*memset((void *) page, 0, PAGE_SIZE); */
  600. page_nr = (int) ((page - hwc_data.kmem_start) >> 12);
  601. clear_bit (page_nr, &hwc_data.kmem_pages);
  602. } else
  603. free_page (page);
  604. #ifdef BUFFER_STRESS_TEST
  606. internal_print (
  607.        DELAYED_WRITE,
  608.        "*** " HWC_RW_PRINT_HEADER
  609.  "page at 0x%x released, %i pages still in use ***n",
  610.        page, hwc_data.hwcb_count);
  612. #endif
  613. }
  614. return 0;
  615. }
  617. static int 
  618. add_mto (
  619. unsigned char *message,
  620. unsigned short int count)
  621. {
  622. unsigned short int mto_size;
  623. write_hwcb_t *hwcb;
  624. mto_t *mto;
  625. void *dest;
  627. if (!BUF_HWCB)
  628. return -ENOMEM;
  630. if (BUF_HWCB == hwc_data.current_hwcb)
  631. return -ENOMEM;
  633. mto_size = sizeof (mto_t) + count;
  635. hwcb = (write_hwcb_t *) BUF_HWCB;
  637. if ((MAX_HWCB_ROOM - hwcb->length) < mto_size)
  638. return -ENOMEM;
  640. mto = (mto_t *) (((unsigned long) hwcb) + hwcb->length);
  642. memcpy (mto, &mto_template, sizeof (mto_t));
  644. dest = (void *) (((unsigned long) mto) + sizeof (mto_t));
  646. memcpy (dest, message, count);
  648. mto->length += count;
  650. hwcb->length += mto_size;
  651. hwcb->msgbuf.length += mto_size;
  652. hwcb->msgbuf.mdb.length += mto_size;
  654. BUF_HWCB_MTO++;
  655. ALL_HWCB_MTO++;
  656. BUF_HWCB_CHAR += count;
  657. ALL_HWCB_CHAR += count;
  659. return count;
  660. }
  662. static int write_event_data_1 (void);
  664. static void 
  665. do_poll_hwc (unsigned long data)
  666. {
  667. unsigned long flags;
  669. spin_lock_irqsave (&hwc_data.lock, flags);
  671. write_event_data_1 ();
  673. spin_unlock_irqrestore (&hwc_data.lock, flags);
  674. }
  676. void 
  677. start_poll_hwc (void)
  678. {
  679. init_timer (&hwc_data.poll_timer);
  680. hwc_data.poll_timer.function = do_poll_hwc;
  681. hwc_data.poll_timer.data = (unsigned long) NULL;
  682. hwc_data.poll_timer.expires = jiffies + 2 * HZ;
  683. add_timer (&hwc_data.poll_timer);
  684. hwc_data.flags |= HWC_PTIMER_RUNS;
  685. }
  687. static int 
  688. write_event_data_1 (void)
  689. {
  690. unsigned short int condition_code;
  691. int retval;
  692. write_hwcb_t *hwcb = (write_hwcb_t *) OUT_HWCB;
  694. if ((!hwc_data.write_prio) &&
  695.     (!hwc_data.write_nonprio) &&
  696.     hwc_data.read_statechange)
  697. return -EOPNOTSUPP;
  699. if (hwc_data.current_servc)
  700. return -EBUSY;
  702. retval = sane_write_hwcb ();
  703. if (retval < 0)
  704. return -EIO;
  706. if (!OUT_HWCB_MTO)
  707. return -ENODATA;
  709. if (!hwc_data.write_nonprio && hwc_data.write_prio)
  710. hwcb->msgbuf.type = ET_PMsgCmd;
  711. else
  712. hwcb->msgbuf.type = ET_Msg;
  714. condition_code = service_call (HWC_CMDW_WRITEDATA, OUT_HWCB);
  716. #ifdef DUMP_HWC_WRITE_ERROR
  717. if (condition_code != HWC_COMMAND_INITIATED)
  718. __asm__ ("LHI 1,0xe20nt"
  719.  "L 2,0(%0)nt"
  720.  "LRA 3,0(%1)nt"
  721.  "J .+0 nt"
  722.       :
  723.       :  "a" (&condition_code), "a" (OUT_HWCB)
  724.       :  "1", "2", "3");
  725. #endif
  727. switch (condition_code) {
  728. case HWC_COMMAND_INITIATED:
  729. hwc_data.current_servc = HWC_CMDW_WRITEDATA;
  730. hwc_data.current_hwcb = OUT_HWCB;
  731. retval = condition_code;
  732. break;
  733. case HWC_BUSY:
  734. retval = -EBUSY;
  735. break;
  736. case HWC_NOT_OPERATIONAL:
  737. start_poll_hwc ();
  738. default:
  739. retval = -EIO;
  740. }
  742. return retval;
  743. }
  745. static void 
  746. flush_hwcbs (void)
  747. {
  748. while (hwc_data.hwcb_count > 1)
  749. release_write_hwcb ();
  751. release_write_hwcb ();
  753. hwc_data.flags &= ~HWC_FLUSH;
  754. }
  756. static int 
  757. write_event_data_2 (u32 ext_int_param)
  758. {
  759. write_hwcb_t *hwcb;
  760. int retval = 0;
  762. #ifdef DUMP_HWC_WRITE_ERROR
  763. if ((ext_int_param & HWC_EXT_INT_PARAM_ADDR)
  764.     != (unsigned long) hwc_data.current_hwcb) {
  765. internal_print (
  766.        DELAYED_WRITE,
  767.        HWC_RW_PRINT_HEADER
  768.        "write_event_data_2 : "
  769.        "HWCB address does not fit "
  770.        "(expected: 0x%lx, got: 0x%lx).n",
  771.        (unsigned long) hwc_data.current_hwcb,
  772.        ext_int_param);
  773. return -EINVAL;
  774. }
  775. #endif
  777. hwcb = (write_hwcb_t *) OUT_HWCB;
  779. #ifdef DUMP_HWC_WRITE_LIST_ERROR
  780. if (((unsigned char *) hwcb) != hwc_data.current_hwcb) {
  781. __asm__ ("LHI 1,0xe22nt"
  782.  "LRA 2,0(%0)nt"
  783.  "LRA 3,0(%1)nt"
  784.  "LRA 4,0(%2)nt"
  785.  "LRA 5,0(%3)nt"
  786.  "J .+0 nt"
  787.       :
  788.       :  "a" (OUT_HWCB),
  789.  "a" (hwc_data.current_hwcb),
  790.  "a" (BUF_HWCB),
  791.  "a" (hwcb)
  792.       :  "1", "2", "3", "4", "5");
  793. }
  794. #endif
  796. #ifdef DUMP_HWC_WRITE_ERROR
  797. if (hwcb->response_code != 0x0020) {
  798. __asm__ ("LHI 1,0xe21nt"
  799.  "LRA 2,0(%0)nt"
  800.  "LRA 3,0(%1)nt"
  801.  "LRA 4,0(%2)nt"
  802.  "LH 5,0(%3)nt"
  803.  "SRL 5,8nt"
  804.  "J .+0 nt"
  805.       :
  806.       :  "a" (OUT_HWCB), "a" (hwc_data.current_hwcb),
  807.  "a" (BUF_HWCB),
  808.  "a" (&(hwc_data.hwcb_count))
  809.       :  "1", "2", "3", "4", "5");
  810. }
  811. #endif
  813. switch (hwcb->response_code) {
  814. case 0x0020:
  816. retval = OUT_HWCB_CHAR;
  817. release_write_hwcb ();
  818. break;
  819. case 0x0040:
  820. case 0x0340:
  821. case 0x40F0:
  822. if (!hwc_data.read_statechange) {
  823. hwcb->response_code = 0;
  824. start_poll_hwc ();
  825. }
  826. retval = -EIO;
  827. break;
  828. default:
  829. internal_print (
  830.        DELAYED_WRITE,
  831.        HWC_RW_PRINT_HEADER
  832.        "write_event_data_2 : "
  833.        "failed operation "
  834.        "(response code: 0x%x "
  835.        "HWCB address: 0x%x).n",
  836.        hwcb->response_code,
  837.        hwcb);
  838. retval = -EIO;
  839. }
  841. if (retval == -EIO) {
  843. hwcb->control_mask[0] = 0;
  844. hwcb->control_mask[1] = 0;
  845. hwcb->control_mask[2] = 0;
  846. hwcb->response_code = 0;
  847. }
  848. hwc_data.current_servc = 0;
  849. hwc_data.current_hwcb = NULL;
  851. if (hwc_data.flags & HWC_FLUSH)
  852. flush_hwcbs ();
  854. return retval;
  855. }
  857. static void 
  858. do_put_line (
  859.     unsigned char *message,
  860.     unsigned short count)
  861. {
  863. if (add_mto (message, count) != count) {
  865. if (allocate_write_hwcb () < 0)
  866. reuse_write_hwcb ();
  868. #ifdef DUMP_HWC_WRITE_LIST_ERROR
  869. if (add_mto (message, count) != count)
  870. __asm__ ("LHI 1,0xe32nt"
  871.  "LRA 2,0(%0)nt"
  872.  "L 3,0(%1)nt"
  873.  "LRA 4,0(%2)nt"
  874.  "LRA 5,0(%3)nt"
  875.  "J .+0 nt"
  876.       :
  877.       :  "a" (message), "a" (&hwc_data.kmem_pages),
  878.  "a" (BUF_HWCB), "a" (OUT_HWCB)
  879.       :  "1", "2", "3", "4", "5");
  880. #else
  881. add_mto (message, count);
  882. #endif
  883. }
  884. }
  886. static void 
  887. put_line (
  888.  unsigned char *message,
  889.  unsigned short count)
  890. {
  892. if ((!hwc_data.obuf_start) && (hwc_data.flags & HWC_WTIMER_RUNS)) {
  893. del_timer (&hwc_data.write_timer);
  894. hwc_data.flags &= ~HWC_WTIMER_RUNS;
  895. }
  896. hwc_data.obuf_start += count;
  898. do_put_line (message, count);
  900. hwc_data.obuf_start -= count;
  901. }
  903. static void 
  904. set_alarm (void)
  905. {
  906. write_hwcb_t *hwcb;
  908. if ((!BUF_HWCB) || (BUF_HWCB == hwc_data.current_hwcb))
  909. allocate_write_hwcb ();
  911. hwcb = (write_hwcb_t *) BUF_HWCB;
  912. hwcb->msgbuf.mdb.mdb_body.go.general_msg_flags |= GMF_SndAlrm;
  913. }
  915. static void 
  916. hwc_write_timeout (unsigned long data)
  917. {
  918. unsigned long flags;
  920. spin_lock_irqsave (&hwc_data.lock, flags);
  922. hwc_data.obuf_start = hwc_data.obuf_count;
  923. if (hwc_data.obuf_count)
  924. put_line (hwc_data.obuf, hwc_data.obuf_count);
  925. hwc_data.obuf_start = 0;
  927. hwc_data.obuf_cursor = 0;
  928. hwc_data.obuf_count = 0;
  930. write_event_data_1 ();
  932. spin_unlock_irqrestore (&hwc_data.lock, flags);
  933. }
  935. static int 
  936. do_hwc_write (
  937.      int from_user,
  938.      unsigned char *msg,
  939.      unsigned int count,
  940.      unsigned char write_time)
  941. {
  942. unsigned int i_msg = 0;
  943. unsigned short int spaces = 0;
  944. unsigned int processed_characters = 0;
  945. unsigned char ch;
  946. unsigned short int obuf_count;
  947. unsigned short int obuf_cursor;
  948. unsigned short int obuf_columns;
  950. if (hwc_data.obuf_start) {
  951. obuf_cursor = 0;
  952. obuf_count = 0;
  953. obuf_columns = MIN (hwc_data.ioctls.columns,
  954.     MAX_MESSAGE_SIZE - hwc_data.obuf_start);
  955. } else {
  956. obuf_cursor = hwc_data.obuf_cursor;
  957. obuf_count = hwc_data.obuf_count;
  958. obuf_columns = hwc_data.ioctls.columns;
  959. }
  961. for (i_msg = 0; i_msg < count; i_msg++) {
  962. if (from_user)
  963. get_user (ch, msg + i_msg);
  964. else
  965. ch = msg[i_msg];
  967. processed_characters++;
  969. if ((obuf_cursor == obuf_columns) &&
  971.     (ch != 'n') &&
  973.     (ch != 't')) {
  974. put_line (&hwc_data.obuf[hwc_data.obuf_start],
  975.   obuf_columns);
  976. obuf_cursor = 0;
  977. obuf_count = 0;
  978. }
  979. switch (ch) {
  981. case 'n':
  983. put_line (&hwc_data.obuf[hwc_data.obuf_start],
  984.   obuf_count);
  985. obuf_cursor = 0;
  986. obuf_count = 0;
  987. break;
  989. case 'a':
  991. hwc_data.obuf_start += obuf_count;
  992. set_alarm ();
  993. hwc_data.obuf_start -= obuf_count;
  995. break;
  997. case 't':
  999. do {
  1000. if (obuf_cursor < obuf_columns) {
  1001. hwc_data.obuf[hwc_data.obuf_start +
  1002.       obuf_cursor]
  1003.     = HWC_ASCEBC (' ');
  1004. obuf_cursor++;
  1005. } else
  1006. break;
  1007. } while (obuf_cursor % hwc_data.ioctls.width_htab);
  1009. break;
  1011. case 'f':
  1012. case 'v':
  1014. spaces = obuf_cursor;
  1015. put_line (&hwc_data.obuf[hwc_data.obuf_start],
  1016.   obuf_count);
  1017. obuf_count = obuf_cursor;
  1018. while (spaces) {
  1019. hwc_data.obuf[hwc_data.obuf_start +
  1020.       obuf_cursor - spaces]
  1021.     = HWC_ASCEBC (' ');
  1022. spaces--;
  1023. }
  1025. break;
  1027. case 'b':
  1029. if (obuf_cursor)
  1030. obuf_cursor--;
  1031. break;
  1033. case 'r':
  1035. obuf_cursor = 0;
  1036. break;
  1038. case 0x00:
  1040. put_line (&hwc_data.obuf[hwc_data.obuf_start],
  1041.   obuf_count);
  1042. obuf_cursor = 0;
  1043. obuf_count = 0;
  1044. goto out;
  1046. default:
  1048. if (isprint (ch))
  1049. hwc_data.obuf[hwc_data.obuf_start +
  1050.       obuf_cursor++]
  1051.     = HWC_ASCEBC (ch);
  1052. }
  1053. if (obuf_cursor > obuf_count)
  1054. obuf_count = obuf_cursor;
  1055. }
  1057. if (obuf_cursor) {
  1059. if (hwc_data.obuf_start ||
  1060.     (hwc_data.ioctls.final_nl == 0)) {
  1062. put_line (&hwc_data.obuf[hwc_data.obuf_start],
  1063.   obuf_count);
  1064. obuf_cursor = 0;
  1065. obuf_count = 0;
  1066. } else {
  1068. if (hwc_data.ioctls.final_nl > 0) {
  1070. if (hwc_data.flags & HWC_WTIMER_RUNS) {
  1072. mod_timer (&hwc_data.write_timer,
  1073.    jiffies + hwc_data.ioctls.final_nl * HZ / 10);
  1074. } else {
  1076. init_timer (&hwc_data.write_timer);
  1077. hwc_data.write_timer.function =
  1078.     hwc_write_timeout;
  1079. hwc_data.write_timer.data =
  1080.     (unsigned long) NULL;
  1081. hwc_data.write_timer.expires =
  1082.     jiffies +
  1083.     hwc_data.ioctls.final_nl * HZ / 10;
  1084. add_timer (&hwc_data.write_timer);
  1085. hwc_data.flags |= HWC_WTIMER_RUNS;
  1086. }
  1087. } else;
  1089. }
  1090. } else;
  1092.       out:
  1094. if (!hwc_data.obuf_start) {
  1095. hwc_data.obuf_cursor = obuf_cursor;
  1096. hwc_data.obuf_count = obuf_count;
  1097. }
  1098. if (write_time == IMMEDIATE_WRITE)
  1099. write_event_data_1 ();
  1101. return processed_characters;
  1102. }
  1104. signed int 
  1105. hwc_write (int from_user, const unsigned char *msg, unsigned int count)
  1106. {
  1107. unsigned long flags;
  1108. int retval;
  1110. spin_lock_irqsave (&hwc_data.lock, flags);
  1112. retval = do_hwc_write (from_user, (unsigned char *) msg,
  1113.        count, IMMEDIATE_WRITE);
  1115. spin_unlock_irqrestore (&hwc_data.lock, flags);
  1117. return retval;
  1118. }
  1120. unsigned int 
  1121. hwc_chars_in_buffer (unsigned char flag)
  1122. {
  1123. unsigned short int number = 0;
  1124. unsigned long flags;
  1126. spin_lock_irqsave (&hwc_data.lock, flags);
  1128. if (flag & IN_HWCB)
  1129. number += ALL_HWCB_CHAR;
  1131. if (flag & IN_WRITE_BUF)
  1132. number += hwc_data.obuf_cursor;
  1134. spin_unlock_irqrestore (&hwc_data.lock, flags);
  1136. return number;
  1137. }
  1139. static inline int 
  1140. nr_setbits (kmem_pages_t arg)
  1141. {
  1142. int i;
  1143. int nr = 0;
  1145. for (i = 0; i < (sizeof (arg) << 3); i++) {
  1146. if (arg & 1)
  1147. nr++;
  1148. arg >>= 1;
  1149. }
  1151. return nr;
  1152. }
  1154. unsigned int 
  1155. hwc_write_room (unsigned char flag)
  1156. {
  1157. unsigned int number = 0;
  1158. unsigned long flags;
  1159. write_hwcb_t *hwcb;
  1161. spin_lock_irqsave (&hwc_data.lock, flags);
  1163. if (flag & IN_HWCB) {
  1165. if (BUF_HWCB) {
  1166. hwcb = (write_hwcb_t *) BUF_HWCB;
  1167. number += MAX_HWCB_ROOM - hwcb->length;
  1168. }
  1169. number += (hwc_data.ioctls.kmem_hwcb -
  1170.    nr_setbits (hwc_data.kmem_pages)) *
  1171.     (MAX_HWCB_ROOM -
  1172.      (sizeof (write_hwcb_t) + sizeof (mto_t)));
  1173. }
  1174. if (flag & IN_WRITE_BUF)
  1175. number += MAX_HWCB_ROOM - hwc_data.obuf_cursor;
  1177. spin_unlock_irqrestore (&hwc_data.lock, flags);
  1179. return number;
  1180. }
  1182. void 
  1183. hwc_flush_buffer (unsigned char flag)
  1184. {
  1185. unsigned long flags;
  1187. spin_lock_irqsave (&hwc_data.lock, flags);
  1189. if (flag & IN_HWCB) {
  1190. if (hwc_data.current_servc != HWC_CMDW_WRITEDATA)
  1191. flush_hwcbs ();
  1192. else
  1193. hwc_data.flags |= HWC_FLUSH;
  1194. }
  1195. if (flag & IN_WRITE_BUF) {
  1196. hwc_data.obuf_cursor = 0;
  1197. hwc_data.obuf_count = 0;
  1198. }
  1199. spin_unlock_irqrestore (&hwc_data.lock, flags);
  1200. }
  1202. unsigned short int 
  1203. seperate_cases (unsigned char *buf, unsigned short int count)
  1204. {
  1206. unsigned short int i_in;
  1208. unsigned short int i_out = 0;
  1210. unsigned char _case = 0;
  1212. for (i_in = 0; i_in < count; i_in++) {
  1214. if (buf[i_in] == hwc_data.ioctls.delim) {
  1216. if ((i_in + 1 < count) &&
  1217.     (buf[i_in + 1] == hwc_data.ioctls.delim)) {
  1219. buf[i_out] = hwc_data.ioctls.delim;
  1221. i_out++;
  1223. i_in++;
  1225. } else
  1226. _case = ~_case;
  1228. } else {
  1230. if (_case) {
  1232. if (hwc_data.ioctls.tolower)
  1233. buf[i_out] = _ebc_toupper[buf[i_in]];
  1235. else
  1236. buf[i_out] = _ebc_tolower[buf[i_in]];
  1238. } else
  1239. buf[i_out] = buf[i_in];
  1241. i_out++;
  1242. }
  1243. }
  1245. return i_out;
  1246. }
  1248. #ifdef DUMP_HWCB_INPUT
  1250. static int 
  1251. gds_vector_name (u16 id, unsigned char name[])
  1252. {
  1253. int retval = 0;
  1255. switch (id) {
  1256. case GDS_ID_MDSMU:
  1257. name = "Multiple Domain Support Message Unit";
  1258. break;
  1259. case GDS_ID_MDSRouteInfo:
  1260. name = "MDS Routing Information";
  1261. break;
  1262. case GDS_ID_AgUnWrkCorr:
  1263. name = "Agent Unit of Work Correlator";
  1264. break;
  1265. case GDS_ID_SNACondReport:
  1266. name = "SNA Condition Report";
  1267. break;
  1268. case GDS_ID_CPMSU:
  1269. name = "CP Management Services Unit";
  1270. break;
  1271. case GDS_ID_RoutTargInstr:
  1272. name = "Routing and Targeting Instructions";
  1273. break;
  1274. case GDS_ID_OpReq:
  1275. name = "Operate Request";
  1276. break;
  1277. case GDS_ID_TextCmd:
  1278. name = "Text Command";
  1279. break;
  1281. default:
  1282. name = "unknown GDS variable";
  1283. retval = -EINVAL;
  1284. }
  1286. return retval;
  1287. }
  1288. #endif
  1290. inline static gds_vector_t *
  1291. find_gds_vector (
  1292. gds_vector_t * start, void *end, u16 id)
  1293. {
  1294. gds_vector_t *vec;
  1295. gds_vector_t *retval = NULL;
  1297. vec = start;
  1299. while (((void *) vec) < end) {
  1300. if (vec->gds_id == id) {
  1302. #ifdef DUMP_HWCB_INPUT
  1303. int retval_name;
  1304. unsigned char name[64];
  1306. retval_name = gds_vector_name (id, name);
  1307. internal_print (
  1308.        DELAYED_WRITE,
  1309.        HWC_RW_PRINT_HEADER
  1310.   "%s at 0x%x up to 0x%x, length: %d",
  1311.        name,
  1312.        (unsigned long) vec,
  1313.       ((unsigned long) vec) + vec->length - 1,
  1314.        vec->length);
  1315. if (retval_name < 0)
  1316. internal_print (
  1317.        IMMEDIATE_WRITE,
  1318.        ", id: 0x%xn",
  1319.        vec->gds_id);
  1320. else
  1321. internal_print (
  1322.        IMMEDIATE_WRITE,
  1323.        "n");
  1324. #endif
  1326. retval = vec;
  1327. break;
  1328. }
  1329. vec = (gds_vector_t *) (((unsigned long) vec) + vec->length);
  1330. }
  1332. return retval;
  1333. }
  1335. inline static gds_subvector_t *
  1336. find_gds_subvector (
  1337.    gds_subvector_t * start, void *end, u8 key)
  1338. {
  1339. gds_subvector_t *subvec;
  1340. gds_subvector_t *retval = NULL;
  1342. subvec = start;
  1344. while (((void *) subvec) < end) {
  1345. if (subvec->key == key) {
  1346. retval = subvec;
  1347. break;
  1348. }
  1349. subvec = (gds_subvector_t *)
  1350.     (((unsigned long) subvec) + subvec->length);
  1351. }
  1353. return retval;
  1354. }
  1356. inline static int 
  1357. get_input (void *start, void *end)
  1358. {
  1359. int count;
  1361. count = ((unsigned long) end) - ((unsigned long) start);
  1363. if (hwc_data.ioctls.tolower)
  1364. EBC_TOLOWER (start, count);
  1366. if (hwc_data.ioctls.delim)
  1367. count = seperate_cases (start, count);
  1369. HWC_EBCASC_STR (start, count);
  1371. if (hwc_data.ioctls.echo)
  1372. do_hwc_write (0, start, count, IMMEDIATE_WRITE);
  1374. if (hwc_data.calls != NULL)
  1375. if (hwc_data.calls->move_input != NULL)
  1376. (hwc_data.calls->move_input) (start, count);
  1378. return count;
  1379. }
  1381. inline static int 
  1382. eval_selfdeftextmsg (gds_subvector_t * start, void *end)
  1383. {
  1384. gds_subvector_t *subvec;
  1385. void *subvec_data;
  1386. void *subvec_end;
  1387. int retval = 0;
  1389. subvec = start;
  1391. while (((void *) subvec) < end) {
  1392. subvec = find_gds_subvector (subvec, end, 0x30);
  1393. if (!subvec)
  1394. break;
  1395. subvec_data = (void *)
  1396.     (((unsigned long) subvec) +
  1397.      sizeof (gds_subvector_t));
  1398. subvec_end = (void *)
  1399.     (((unsigned long) subvec) + subvec->length);
  1400. retval += get_input (subvec_data, subvec_end);
  1401. subvec = (gds_subvector_t *) subvec_end;
  1402. }
  1404. return retval;
  1405. }
  1407. inline static int 
  1408. eval_textcmd (gds_subvector_t * start, void *end)
  1409. {
  1410. gds_subvector_t *subvec;
  1411. gds_subvector_t *subvec_data;
  1412. void *subvec_end;
  1413. int retval = 0;
  1415. subvec = start;
  1417. while (((void *) subvec) < end) {
  1418. subvec = find_gds_subvector (
  1419.  subvec, end, GDS_KEY_SelfDefTextMsg);
  1420. if (!subvec)
  1421. break;
  1422. subvec_data = (gds_subvector_t *)
  1423.     (((unsigned long) subvec) +
  1424.      sizeof (gds_subvector_t));
  1425. subvec_end = (void *)
  1426.     (((unsigned long) subvec) + subvec->length);
  1427. retval += eval_selfdeftextmsg (subvec_data, subvec_end);
  1428. subvec = (gds_subvector_t *) subvec_end;
  1429. }
  1431. return retval;
  1432. }
  1434. inline static int 
  1435. eval_cpmsu (gds_vector_t * start, void *end)
  1436. {
  1437. gds_vector_t *vec;
  1438. gds_subvector_t *vec_data;
  1439. void *vec_end;
  1440. int retval = 0;
  1442. vec = start;
  1444. while (((void *) vec) < end) {
  1445. vec = find_gds_vector (vec, end, GDS_ID_TextCmd);
  1446. if (!vec)
  1447. break;
  1448. vec_data = (gds_subvector_t *)
  1449.     (((unsigned long) vec) + sizeof (gds_vector_t));
  1450. vec_end = (void *) (((unsigned long) vec) + vec->length);
  1451. retval += eval_textcmd (vec_data, vec_end);
  1452. vec = (gds_vector_t *) vec_end;
  1453. }
  1455. return retval;
  1456. }
  1458. inline static int 
  1459. eval_mdsmu (gds_vector_t * start, void *end)
  1460. {
  1461. gds_vector_t *vec;
  1462. gds_vector_t *vec_data;
  1463. void *vec_end;
  1464. int retval = 0;
  1466. vec = find_gds_vector (start, end, GDS_ID_CPMSU);
  1467. if (vec) {
  1468. vec_data = (gds_vector_t *)
  1469.     (((unsigned long) vec) + sizeof (gds_vector_t));
  1470. vec_end = (void *) (((unsigned long) vec) + vec->length);
  1471. retval = eval_cpmsu (vec_data, vec_end);
  1472. }
  1473. return retval;
  1474. }
  1476. static int 
  1477. eval_evbuf (gds_vector_t * start, void *end)
  1478. {
  1479. gds_vector_t *vec;
  1480. gds_vector_t *vec_data;
  1481. void *vec_end;
  1482. int retval = 0;
  1484. vec = find_gds_vector (start, end, GDS_ID_MDSMU);
  1485. if (vec) {
  1486. vec_data = (gds_vector_t *)
  1487.     (((unsigned long) vec) + sizeof (gds_vector_t));
  1488. vec_end = (void *) (((unsigned long) vec) + vec->length);
  1489. retval = eval_mdsmu (vec_data, vec_end);
  1490. }
  1491. return retval;
  1492. }
  1494. static inline int 
  1495. eval_hwc_receive_mask (_hwcb_mask_t mask)
  1496. {
  1498. hwc_data.write_nonprio
  1499.     = ((mask & ET_Msg_Mask) == ET_Msg_Mask);
  1501. hwc_data.write_prio
  1502.     = ((mask & ET_PMsgCmd_Mask) == ET_PMsgCmd_Mask);
  1504. if (hwc_data.write_prio || hwc_data.write_nonprio) {
  1505. internal_print (
  1506.        DELAYED_WRITE,
  1507.        HWC_RW_PRINT_HEADER
  1508.        "can write messagesn");
  1509. return 0;
  1510. } else {
  1511. internal_print (
  1512.        DELAYED_WRITE,
  1513.        HWC_RW_PRINT_HEADER
  1514.        "can not write messagesn");
  1515. return -1;
  1516. }
  1517. }
  1519. static inline int 
  1520. eval_hwc_send_mask (_hwcb_mask_t mask)
  1521. {
  1523. hwc_data.read_statechange
  1524.     = ((mask & ET_StateChange_Mask) == ET_StateChange_Mask);
  1525. if (hwc_data.read_statechange)
  1526. internal_print (
  1527.        DELAYED_WRITE,
  1528.        HWC_RW_PRINT_HEADER
  1529.      "can read state change notificationsn");
  1530. else
  1531. internal_print (
  1532.        DELAYED_WRITE,
  1533.        HWC_RW_PRINT_HEADER
  1534.  "can not read state change notificationsn");
  1536. hwc_data.sig_quiesce
  1537.     = ((mask & ET_SigQuiesce_Mask) == ET_SigQuiesce_Mask);
  1538. if (hwc_data.sig_quiesce)
  1539. internal_print (
  1540.        DELAYED_WRITE,
  1541.        HWC_RW_PRINT_HEADER
  1542.        "can receive signal quiescen");
  1543. else
  1544. internal_print (
  1545.        DELAYED_WRITE,
  1546.        HWC_RW_PRINT_HEADER
  1547.        "can not receive signal quiescen");
  1549. hwc_data.read_nonprio
  1550.     = ((mask & ET_OpCmd_Mask) == ET_OpCmd_Mask);
  1551. if (hwc_data.read_nonprio)
  1552. internal_print (
  1553.        DELAYED_WRITE,
  1554.        HWC_RW_PRINT_HEADER
  1555.        "can read commandsn");
  1557. hwc_data.read_prio
  1558.     = ((mask & ET_PMsgCmd_Mask) == ET_PMsgCmd_Mask);
  1559. if (hwc_data.read_prio)
  1560. internal_print (
  1561.        DELAYED_WRITE,
  1562.        HWC_RW_PRINT_HEADER
  1563.        "can read priority commandsn");
  1565. if (hwc_data.read_prio || hwc_data.read_nonprio) {
  1566. return 0;
  1567. } else {
  1568. internal_print (
  1569.        DELAYED_WRITE,
  1570.        HWC_RW_PRINT_HEADER
  1571.      "can not read commands from operatorn");
  1572. return -1;
  1573. }
  1574. }
  1576. static int 
  1577. eval_statechangebuf (statechangebuf_t * scbuf)
  1578. {
  1579. int retval = 0;
  1581. internal_print (
  1582.        DELAYED_WRITE,
  1583.        HWC_RW_PRINT_HEADER
  1584.        "HWC state change detectedn");
  1586. if (scbuf->validity_hwc_active_facility_mask) {
  1588. }
  1589. if (scbuf->validity_hwc_receive_mask) {
  1591. if (scbuf->mask_length != 4) {
  1592. #ifdef DUMP_HWC_INIT_ERROR
  1593. __asm__ ("LHI 1,0xe50nt"
  1594.  "LRA 2,0(%0)nt"
  1595.  "J .+0 nt"
  1596.       :
  1597.       :  "a" (scbuf)
  1598.       :  "1", "2");
  1599. #endif
  1600. } else {
  1602. retval += eval_hwc_receive_mask
  1603.     (scbuf->hwc_receive_mask);
  1604. }
  1605. }
  1606. if (scbuf->validity_hwc_send_mask) {
  1608. if (scbuf->mask_length != 4) {
  1609. #ifdef DUMP_HWC_INIT_ERROR
  1610. __asm__ ("LHI 1,0xe51nt"
  1611.  "LRA 2,0(%0)nt"
  1612.  "J .+0 nt"
  1613.       :
  1614.       :  "a" (scbuf)
  1615.       :  "1", "2");
  1616. #endif
  1617. } else {
  1619. retval += eval_hwc_send_mask
  1620.     (scbuf->hwc_send_mask);
  1621. }
  1622. }
  1623. if (scbuf->validity_read_data_function_mask) {
  1625. }
  1626. return retval;
  1627. }
  1629. #ifdef CONFIG_SMP
  1630. extern unsigned long cpu_online_map;
  1631. static volatile unsigned long cpu_quiesce_map;
  1633. static void 
  1634. do_load_quiesce_psw (void)
  1635. {
  1636. psw_t quiesce_psw;
  1638. clear_bit (smp_processor_id (), &cpu_quiesce_map);
  1639. if (smp_processor_id () == 0) {
  1641. while (cpu_quiesce_map != 0) ;
  1643. quiesce_psw.mask = _DW_PSW_MASK;
  1644. quiesce_psw.addr = 0xfff;
  1645. __load_psw (quiesce_psw);
  1646. }
  1647. signal_processor (smp_processor_id (), sigp_stop);
  1648. }
  1650. static void 
  1651. do_machine_quiesce (void)
  1652. {
  1653. cpu_quiesce_map = cpu_online_map;
  1654. smp_call_function (do_load_quiesce_psw, NULL, 0, 0);
  1655. do_load_quiesce_psw ();
  1656. }
  1658. #else
  1659. static void 
  1660. do_machine_quiesce (void)
  1661. {
  1662. psw_t quiesce_psw;
  1664. quiesce_psw.mask = _DW_PSW_MASK;
  1665. queisce_psw.addr = 0xfff;
  1666. __load_psw (quiesce_psw);
  1667. }
  1669. #endif
  1671. static int 
  1672. process_evbufs (void *start, void *end)
  1673. {
  1674. int retval = 0;
  1675. evbuf_t *evbuf;
  1676. void *evbuf_end;
  1677. gds_vector_t *evbuf_data;
  1679. evbuf = (evbuf_t *) start;
  1680. while (((void *) evbuf) < end) {
  1681. evbuf_data = (gds_vector_t *)
  1682.     (((unsigned long) evbuf) + sizeof (evbuf_t));
  1683. evbuf_end = (void *) (((unsigned long) evbuf) + evbuf->length);
  1684. switch (evbuf->type) {
  1685. case ET_OpCmd:
  1686. case ET_CntlProgOpCmd:
  1687. case ET_PMsgCmd:
  1688. #ifdef DUMP_HWCB_INPUT
  1690. internal_print (
  1691.        DELAYED_WRITE,
  1692.        HWC_RW_PRINT_HEADER
  1693.        "event buffer "
  1694.    "at 0x%x up to 0x%x, length: %dn",
  1695.        (unsigned long) evbuf,
  1696.        (unsigned long) (evbuf_end - 1),
  1697.        evbuf->length);
  1698. dump_storage_area ((void *) evbuf, evbuf->length);
  1699. #endif
  1700. retval += eval_evbuf (evbuf_data, evbuf_end);
  1701. break;
  1702. case ET_StateChange:
  1703. retval += eval_statechangebuf
  1704.     ((statechangebuf_t *) evbuf);
  1705. break;
  1706. case ET_SigQuiesce:
  1708. _machine_restart = do_machine_quiesce;
  1709. _machine_halt = do_machine_quiesce;
  1710. _machine_power_off = do_machine_quiesce;
  1711. ctrl_alt_del ();
  1712. break;
  1713. default:
  1714. internal_print (
  1715.        DELAYED_WRITE,
  1716.        HWC_RW_PRINT_HEADER
  1717.        "unconditional read: "
  1718.        "unknown event buffer found, "
  1719.        "type 0x%x",
  1720.        evbuf->type);
  1721. retval = -ENOSYS;
  1722. }
  1723. evbuf = (evbuf_t *) evbuf_end;
  1724. }
  1725. return retval;
  1726. }
  1728. static int 
  1729. unconditional_read_1 (void)
  1730. {
  1731. unsigned short int condition_code;
  1732. read_hwcb_t *hwcb = (read_hwcb_t *) hwc_data.page;
  1733. int retval;
  1735. #if 0
  1737. if ((!hwc_data.read_prio) && (!hwc_data.read_nonprio))
  1738. return -EOPNOTSUPP;
  1740. if (hwc_data.current_servc)
  1741. return -EBUSY;
  1742. #endif
  1744. memset (hwcb, 0x00, PAGE_SIZE);
  1745. memcpy (hwcb, &read_hwcb_template, sizeof (read_hwcb_t));
  1747. condition_code = service_call (HWC_CMDW_READDATA, hwc_data.page);
  1749. #ifdef DUMP_HWC_READ_ERROR
  1750. if (condition_code == HWC_NOT_OPERATIONAL)
  1751. __asm__ ("LHI 1,0xe40nt"
  1752.  "L 2,0(%0)nt"
  1753.  "LRA 3,0(%1)nt"
  1754.  "J .+0 nt"
  1755.       :
  1756.       :  "a" (&condition_code), "a" (hwc_data.page)
  1757.       :  "1", "2", "3");
  1758. #endif
  1760. switch (condition_code) {
  1761. case HWC_COMMAND_INITIATED:
  1762. hwc_data.current_servc = HWC_CMDW_READDATA;
  1763. hwc_data.current_hwcb = hwc_data.page;
  1764. retval = condition_code;
  1765. break;
  1766. case HWC_BUSY:
  1767. retval = -EBUSY;
  1768. break;
  1769. default:
  1770. retval = -EIO;
  1771. }
  1773. return retval;
  1774. }
  1776. static int 
  1777. unconditional_read_2 (u32 ext_int_param)
  1778. {
  1779. read_hwcb_t *hwcb = (read_hwcb_t *) hwc_data.page;
  1781. #ifdef DUMP_HWC_READ_ERROR
  1782. if ((hwcb->response_code != 0x0020) &&
  1783.     (hwcb->response_code != 0x0220) &&
  1784.     (hwcb->response_code != 0x60F0) &&
  1785.     (hwcb->response_code != 0x62F0))
  1786. __asm__ ("LHI 1,0xe41nt"
  1787.  "LRA 2,0(%0)nt"
  1788.  "L 3,0(%1)nt"
  1789.  "J .+0nt"
  1790.       :
  1791.       :  "a" (hwc_data.page), "a" (&(hwcb->response_code))
  1792.       :  "1", "2", "3");
  1793. #endif
  1795. hwc_data.current_servc = 0;
  1796. hwc_data.current_hwcb = NULL;
  1798. switch (hwcb->response_code) {
  1800. case 0x0020:
  1801. case 0x0220:
  1802. return process_evbufs (
  1803.      (void *) (((unsigned long) hwcb) + sizeof (read_hwcb_t)),
  1804.     (void *) (((unsigned long) hwcb) + hwcb->length));
  1806. case 0x60F0:
  1807. case 0x62F0:
  1808. internal_print (
  1809.        IMMEDIATE_WRITE,
  1810.        HWC_RW_PRINT_HEADER
  1811.        "unconditional read: "
  1812.      "got interrupt and tried to read input, "
  1813.   "but nothing found (response code=0x%x).n",
  1814.        hwcb->response_code);
  1815. return 0;
  1817. case 0x0100:
  1818. internal_print (
  1819.        IMMEDIATE_WRITE,
  1820.        HWC_RW_PRINT_HEADER
  1821.  "unconditional read: HWCB boundary violation - this "
  1822.  "must not occur in a correct driver, please contact "
  1823.        "authorn");
  1824. return -EIO;
  1826. case 0x0300:
  1827. internal_print (
  1828.        IMMEDIATE_WRITE,
  1829.        HWC_RW_PRINT_HEADER
  1830.        "unconditional read: "
  1831. "insufficient HWCB length - this must not occur in a "
  1832.    "correct driver, please contact authorn");
  1833. return -EIO;
  1835. case 0x01F0:
  1836. internal_print (
  1837.        IMMEDIATE_WRITE,
  1838.        HWC_RW_PRINT_HEADER
  1839.        "unconditional read: "
  1840.  "invalid command - this must not occur in a correct "
  1841.        "driver, please contact authorn");
  1842. return -EIO;
  1844. case 0x40F0:
  1845. internal_print (
  1846.        IMMEDIATE_WRITE,
  1847.        HWC_RW_PRINT_HEADER
  1848.        "unconditional read: invalid function coden");
  1849. return -EIO;
  1851. case 0x70F0:
  1852. internal_print (
  1853.        IMMEDIATE_WRITE,
  1854.        HWC_RW_PRINT_HEADER
  1855.       "unconditional read: invalid selection maskn");
  1856. return -EIO;
  1858. case 0x0040:
  1859. internal_print (
  1860.        IMMEDIATE_WRITE,
  1861.        HWC_RW_PRINT_HEADER
  1862.  "unconditional read: HWC equipment checkn");
  1863. return -EIO;
  1865. default:
  1866. internal_print (
  1867.        IMMEDIATE_WRITE,
  1868.        HWC_RW_PRINT_HEADER
  1869. "unconditional read: invalid response code %x - this "
  1870.  "must not occur in a correct driver, please contact "
  1871.        "authorn",
  1872.        hwcb->response_code);
  1873. return -EIO;
  1874. }
  1875. }
  1877. static int 
  1878. write_event_mask_1 (void)
  1879. {
  1880. unsigned int condition_code;
  1881. int retval;
  1883. condition_code = service_call (HWC_CMDW_WRITEMASK, hwc_data.page);
  1885. #ifdef DUMP_HWC_INIT_ERROR
  1887. if (condition_code == HWC_NOT_OPERATIONAL)
  1888. __asm__ ("LHI 1,0xe10nt"
  1889.  "L 2,0(%0)nt"
  1890.  "LRA 3,0(%1)nt"
  1891.  "J .+0nt"
  1892.       :
  1893.       :  "a" (&condition_code), "a" (hwc_data.page)
  1894.       :  "1", "2", "3");
  1895. #endif
  1897. switch (condition_code) {
  1898. case HWC_COMMAND_INITIATED:
  1899. hwc_data.current_servc = HWC_CMDW_WRITEMASK;
  1900. hwc_data.current_hwcb = hwc_data.page;
  1901. retval = condition_code;
  1902. break;
  1903. case HWC_BUSY:
  1904. retval = -EBUSY;
  1905. break;
  1906. default:
  1907. retval = -EIO;
  1908. }
  1910. return retval;
  1911. }
  1913. static int 
  1914. write_event_mask_2 (u32 ext_int_param)
  1915. {
  1916. init_hwcb_t *hwcb = (init_hwcb_t *) hwc_data.page;
  1917. int retval = 0;
  1919. if (hwcb->response_code != 0x0020) {
  1920. #ifdef DUMP_HWC_INIT_ERROR
  1921. __asm__ ("LHI 1,0xe11nt"
  1922.  "LRA 2,0(%0)nt"
  1923.  "L 3,0(%1)nt"
  1924.  "J .+0nt"
  1925.       :
  1926.       :  "a" (hwcb), "a" (&(hwcb->response_code))
  1927.       :  "1", "2", "3");
  1928. #else
  1929. retval = -1;
  1930. #endif
  1931. } else {
  1932. if (hwcb->mask_length != 4) {
  1933. #ifdef DUMP_HWC_INIT_ERROR
  1934. __asm__ ("LHI 1,0xe52nt"
  1935.  "LRA 2,0(%0)nt"
  1936.  "J .+0 nt"
  1937.       :
  1938.       :  "a" (hwcb)
  1939.       :  "1", "2");
  1940. #endif
  1941. } else {
  1942. retval += eval_hwc_receive_mask
  1943.     (hwcb->hwc_receive_mask);
  1944. retval += eval_hwc_send_mask (hwcb->hwc_send_mask);
  1945. }
  1946. }
  1948. hwc_data.current_servc = 0;
  1949. hwc_data.current_hwcb = NULL;
  1951. return retval;
  1952. }
  1954. static int 
  1955. set_hwc_ioctls (hwc_ioctls_t * ioctls, char correct)
  1956. {
  1957. int retval = 0;
  1958. hwc_ioctls_t tmp;
  1960. if (ioctls->width_htab > MAX_MESSAGE_SIZE) {
  1961. if (correct)
  1962. tmp.width_htab = MAX_MESSAGE_SIZE;
  1963. else
  1964. retval = -EINVAL;
  1965. } else
  1966. tmp.width_htab = ioctls->width_htab;
  1968. tmp.echo = ioctls->echo;
  1970. if (ioctls->columns > MAX_MESSAGE_SIZE) {
  1971. if (correct)
  1972. tmp.columns = MAX_MESSAGE_SIZE;
  1973. else
  1974. retval = -EINVAL;
  1975. } else
  1976. tmp.columns = ioctls->columns;
  1978. tmp.final_nl = ioctls->final_nl;
  1980. if (ioctls->max_hwcb < 2) {
  1981. if (correct)
  1982. tmp.max_hwcb = 2;
  1983. else
  1984. retval = -EINVAL;
  1985. } else
  1986. tmp.max_hwcb = ioctls->max_hwcb;
  1988. tmp.tolower = ioctls->tolower;
  1990. if (ioctls->kmem_hwcb > ioctls->max_hwcb) {
  1991. if (correct)
  1992. tmp.kmem_hwcb = ioctls->max_hwcb;
  1993. else
  1994. retval = -EINVAL;
  1995. } else
  1996. tmp.kmem_hwcb = ioctls->kmem_hwcb;
  1998. if (ioctls->kmem_hwcb > MAX_KMEM_PAGES) {
  1999. if (correct)
  2000. ioctls->kmem_hwcb = MAX_KMEM_PAGES;
  2001. else
  2002. retval = -EINVAL;
  2003. }
  2004. if (ioctls->kmem_hwcb < 2) {
  2005. if (correct)
  2006. ioctls->kmem_hwcb = 2;
  2007. else
  2008. retval = -EINVAL;
  2009. }
  2010. tmp.delim = ioctls->delim;
  2012. if (!(retval < 0))
  2013. hwc_data.ioctls = tmp;
  2015. return retval;
  2016. }
  2018. int 
  2019. do_hwc_init (void)
  2020. {
  2021. int retval;
  2023. memcpy (hwc_data.page, &init_hwcb_template, sizeof (init_hwcb_t));
  2025. do {
  2027. retval = write_event_mask_1 ();
  2029. if (retval == -EBUSY) {
  2031. hwc_data.flags |= HWC_INIT;
  2033. __ctl_store (cr0, 0, 0);
  2034. cr0_save = cr0;
  2035. cr0 |= 0x00000200;
  2036. cr0 &= 0xFFFFF3AC;
  2037. __ctl_load (cr0, 0, 0);
  2039. asm volatile ("STOSM %0,0x01"
  2040.       :"=m" (psw_mask)::"memory");
  2042. while (!(hwc_data.flags & HWC_INTERRUPT))
  2043. barrier ();
  2045. asm volatile ("STNSM %0,0xFE"
  2046.       :"=m" (psw_mask)::"memory");
  2048. __ctl_load (cr0_save, 0, 0);
  2050. hwc_data.flags &= ~HWC_INIT;
  2051. }
  2052. } while (retval == -EBUSY);
  2054. if (retval == -EIO) {
  2055. hwc_data.flags |= HWC_BROKEN;
  2056. printk (HWC_RW_PRINT_HEADER "HWC not operationaln");
  2057. }
  2058. return retval;
  2059. }
  2061. void hwc_interrupt_handler (struct pt_regs *regs, __u16 code);
  2063. int 
  2064. hwc_init (void)
  2065. {
  2066. int retval;
  2068. #ifdef BUFFER_STRESS_TEST
  2070. init_hwcb_t *hwcb;
  2071. int i;
  2073. #endif
  2075. if (register_early_external_interrupt (0x2401, hwc_interrupt_handler,
  2076.        &ext_int_info_hwc) != 0)
  2077. panic ("Couldn't request external interrupts 0x2401");
  2079. spin_lock_init (&hwc_data.lock);
  2081. #ifdef USE_VM_DETECTION
  2083. if (MACHINE_IS_VM) {
  2085. if (hwc_data.init_ioctls.columns > 76)
  2086. hwc_data.init_ioctls.columns = 76;
  2087. hwc_data.init_ioctls.tolower = 1;
  2088. if (!hwc_data.init_ioctls.delim)
  2089. hwc_data.init_ioctls.delim = DEFAULT_CASE_DELIMITER;
  2090. } else {
  2091. hwc_data.init_ioctls.tolower = 0;
  2092. hwc_data.init_ioctls.delim = 0;
  2093. }
  2094. #endif
  2095. retval = set_hwc_ioctls (&hwc_data.init_ioctls, 1);
  2097. hwc_data.kmem_start = (unsigned long)
  2098.     alloc_bootmem_low_pages (hwc_data.ioctls.kmem_hwcb * PAGE_SIZE);
  2099. hwc_data.kmem_end = hwc_data.kmem_start +
  2100.     hwc_data.ioctls.kmem_hwcb * PAGE_SIZE - 1;
  2102. retval = do_hwc_init ();
  2104. ctl_set_bit (0, 9);
  2106. #ifdef BUFFER_STRESS_TEST
  2108. internal_print (
  2109.        DELAYED_WRITE,
  2110.        HWC_RW_PRINT_HEADER
  2111.        "use %i bytes for buffering.n",
  2112.        hwc_data.ioctls.kmem_hwcb * PAGE_SIZE);
  2113. for (i = 0; i < 500; i++) {
  2114. hwcb = (init_hwcb_t *) BUF_HWCB;
  2115. internal_print (
  2116.        DELAYED_WRITE,
  2117.        HWC_RW_PRINT_HEADER
  2118.   "This is stress test message #%i, free: %i bytesn",
  2119.        i,
  2120.      MAX_HWCB_ROOM - (hwcb->length + sizeof (mto_t)));
  2121. }
  2123. #endif
  2125. return /*retval */ 0;
  2126. }
  2128. signed int 
  2129. hwc_register_calls (hwc_high_level_calls_t * calls)
  2130. {
  2131. if (calls == NULL)
  2132. return -EINVAL;
  2134. if (hwc_data.calls != NULL)
  2135. return -EBUSY;
  2137. hwc_data.calls = calls;
  2138. return 0;
  2139. }
  2141. signed int 
  2142. hwc_unregister_calls (hwc_high_level_calls_t * calls)
  2143. {
  2144. if (hwc_data.calls == NULL)
  2145. return -EINVAL;
  2147. if (calls != hwc_data.calls)
  2148. return -EINVAL;
  2150. hwc_data.calls = NULL;
  2151. return 0;
  2152. }
  2154. int 
  2155. hwc_send (hwc_request_t * req)
  2156. {
  2157. unsigned long flags;
  2158. int retval;
  2159. int cc;
  2161. spin_lock_irqsave (&hwc_data.lock, flags);
  2162. if (!req || !req->callback || !req->block) {
  2163. retval = -EINVAL;
  2164. goto unlock;
  2165. }
  2166. if (hwc_data.request) {
  2167. retval = -ENOTSUPP;
  2168. goto unlock;
  2169. }
  2170. cc = service_call (req->word, req->block);
  2171. switch (cc) {
  2172. case 0:
  2173. hwc_data.request = req;
  2174. hwc_data.current_servc = req->word;
  2175. hwc_data.current_hwcb = req->block;
  2176. retval = 0;
  2177. break;
  2178. case 2:
  2179. retval = -EBUSY;
  2180. break;
  2181. default:
  2182. retval = -ENOSYS;
  2184. }
  2185.       unlock:
  2186. spin_unlock_irqrestore (&hwc_data.lock, flags);
  2187. return retval;
  2188. }
  2190. EXPORT_SYMBOL (hwc_send);
  2192. void 
  2193. do_hwc_callback (u32 ext_int_param)
  2194. {
  2195. if (!hwc_data.request || !hwc_data.request->callback)
  2196. return;
  2197. if ((ext_int_param & HWC_EXT_INT_PARAM_ADDR)
  2198.     != (unsigned long) hwc_data.request->block)
  2199. return;
  2200. hwc_data.request->callback (hwc_data.request);
  2201. hwc_data.request = NULL;
  2202. hwc_data.current_hwcb = NULL;
  2203. hwc_data.current_servc = 0;
  2204. }
  2206. void 
  2207. hwc_do_interrupt (u32 ext_int_param)
  2208. {
  2209. u32 finished_hwcb = ext_int_param & HWC_EXT_INT_PARAM_ADDR;
  2210. u32 evbuf_pending = ext_int_param & HWC_EXT_INT_PARAM_PEND;
  2212. if (hwc_data.flags & HWC_PTIMER_RUNS) {
  2213. del_timer (&hwc_data.poll_timer);
  2214. hwc_data.flags &= ~HWC_PTIMER_RUNS;
  2215. }
  2216. if (finished_hwcb) {
  2218. if ((unsigned long) hwc_data.current_hwcb != finished_hwcb) {
  2219. internal_print (
  2220.        DELAYED_WRITE,
  2221.        HWC_RW_PRINT_HEADER
  2222.        "interrupt: mismatch: "
  2223.        "ext. int param. (0x%x) vs. "
  2224.        "current HWCB (0x%x)n",
  2225.        ext_int_param,
  2226.        hwc_data.current_hwcb);
  2227. } else {
  2228. if (hwc_data.request) {
  2230. do_hwc_callback (ext_int_param);
  2231. } else {
  2233. switch (hwc_data.current_servc) {
  2235. case HWC_CMDW_WRITEMASK:
  2237. write_event_mask_2 (ext_int_param);
  2238. break;
  2240. case HWC_CMDW_WRITEDATA:
  2242. write_event_data_2 (ext_int_param);
  2243. break;
  2245. case HWC_CMDW_READDATA:
  2247. unconditional_read_2 (ext_int_param);
  2248. break;
  2249. default:
  2250. }
  2251. }
  2252. }
  2253. } else {
  2255. if (hwc_data.current_hwcb) {
  2256. internal_print (
  2257.        DELAYED_WRITE,
  2258.        HWC_RW_PRINT_HEADER
  2259.        "interrupt: mismatch: "
  2260.        "ext. int. param. (0x%x) vs. "
  2261.        "current HWCB (0x%x)n",
  2262.        ext_int_param,
  2263.        hwc_data.current_hwcb);
  2264. }
  2265. }
  2267. if (evbuf_pending) {
  2269. unconditional_read_1 ();
  2270. } else {
  2272. write_event_data_1 ();
  2273. }
  2275. if (!hwc_data.calls || !hwc_data.calls->wake_up)
  2276. return;
  2277. (hwc_data.calls->wake_up) ();
  2278. }
  2280. void 
  2281. hwc_interrupt_handler (struct pt_regs *regs, __u16 code)
  2282. {
  2283. int cpu = smp_processor_id ();
  2285. u32 ext_int_param = hwc_ext_int_param ();
  2287. irq_enter (cpu, 0x2401);
  2289. if (hwc_data.flags & HWC_INIT) {
  2291. hwc_data.flags |= HWC_INTERRUPT;
  2292. } else if (hwc_data.flags & HWC_BROKEN) {
  2294. if (!do_hwc_init ()) {
  2295. hwc_data.flags &= ~HWC_BROKEN;
  2296. internal_print (DELAYED_WRITE,
  2297. HWC_RW_PRINT_HEADER
  2298. "delayed HWC setup after"
  2299. " temporary breakdown"
  2300. " (ext. int. parameter=0x%x)n",
  2301. ext_int_param);
  2302. }
  2303. } else {
  2304. spin_lock (&hwc_data.lock);
  2305. hwc_do_interrupt (ext_int_param);
  2306. spin_unlock (&hwc_data.lock);
  2307. }
  2308. irq_exit (cpu, 0x2401);
  2309. }
  2311. void 
  2312. hwc_unblank (void)
  2313. {
  2315. spin_lock (&hwc_data.lock);
  2316. spin_unlock (&hwc_data.lock);
  2318. __ctl_store (cr0, 0, 0);
  2319. cr0_save = cr0;
  2320. cr0 |= 0x00000200;
  2321. cr0 &= 0xFFFFF3AC;
  2322. __ctl_load (cr0, 0, 0);
  2324. asm volatile ("STOSM %0,0x01":"=m" (psw_mask)::"memory");
  2326. while (ALL_HWCB_CHAR)
  2327. barrier ();
  2329. asm volatile ("STNSM %0,0xFE":"=m" (psw_mask)::"memory");
  2331. __ctl_load (cr0_save, 0, 0);
  2332. }
  2334. int 
  2335. hwc_ioctl (unsigned int cmd, unsigned long arg)
  2336. {
  2337. hwc_ioctls_t tmp = hwc_data.ioctls;
  2338. int retval = 0;
  2339. unsigned long flags;
  2340. unsigned int obuf;
  2342. spin_lock_irqsave (&hwc_data.lock, flags);
  2344. switch (cmd) {
  2346. case TIOCHWCSHTAB:
  2347. if (get_user (tmp.width_htab, (ioctl_htab_t *) arg))
  2348. goto fault;
  2349. break;
  2351. case TIOCHWCSECHO:
  2352. if (get_user (tmp.echo, (ioctl_echo_t *) arg))
  2353. goto fault;
  2354. break;
  2356. case TIOCHWCSCOLS:
  2357. if (get_user (tmp.columns, (ioctl_cols_t *) arg))
  2358. goto fault;
  2359. break;
  2361. case TIOCHWCSNL:
  2362. if (get_user (tmp.final_nl, (ioctl_nl_t *) arg))
  2363. goto fault;
  2364. break;
  2366. case TIOCHWCSOBUF:
  2367. if (get_user (obuf, (unsigned int *) arg))
  2368. goto fault;
  2369. if (obuf & 0xFFF)
  2370. tmp.max_hwcb = (((obuf | 0xFFF) + 1) >> 12);
  2371. else
  2372. tmp.max_hwcb = (obuf >> 12);
  2373. break;
  2375. case TIOCHWCSCASE:
  2376. if (get_user (tmp.tolower, (ioctl_case_t *) arg))
  2377. goto fault;
  2378. break;
  2380. case TIOCHWCSDELIM:
  2381. if (get_user (tmp.delim, (ioctl_delim_t *) arg))
  2382. goto fault;
  2383. break;
  2385. case TIOCHWCSINIT:
  2386. retval = set_hwc_ioctls (&hwc_data.init_ioctls, 1);
  2387. break;
  2389. case TIOCHWCGHTAB:
  2390. if (put_user (tmp.width_htab, (ioctl_htab_t *) arg))
  2391. goto fault;
  2392. break;
  2394. case TIOCHWCGECHO:
  2395. if (put_user (tmp.echo, (ioctl_echo_t *) arg))
  2396. goto fault;
  2397. break;
  2399. case TIOCHWCGCOLS:
  2400. if (put_user (tmp.columns, (ioctl_cols_t *) arg))
  2401. goto fault;
  2402. break;
  2404. case TIOCHWCGNL:
  2405. if (put_user (tmp.final_nl, (ioctl_nl_t *) arg))
  2406. goto fault;
  2407. break;
  2409. case TIOCHWCGOBUF:
  2410. if (put_user (tmp.max_hwcb, (ioctl_obuf_t *) arg))
  2411. goto fault;
  2412. break;
  2414. case TIOCHWCGKBUF:
  2415. if (put_user (tmp.kmem_hwcb, (ioctl_obuf_t *) arg))
  2416. goto fault;
  2417. break;
  2419. case TIOCHWCGCASE:
  2420. if (put_user (tmp.tolower, (ioctl_case_t *) arg))
  2421. goto fault;
  2422. break;
  2424. case TIOCHWCGDELIM:
  2425. if (put_user (tmp.delim, (ioctl_delim_t *) arg))
  2426. goto fault;
  2427. break;
  2428. #if 0
  2430. case TIOCHWCGINIT:
  2431. if (put_user (&hwc_data.init_ioctls, (hwc_ioctls_t *) arg))
  2432. goto fault;
  2433. break;
  2435. case TIOCHWCGCURR:
  2436. if (put_user (&hwc_data.ioctls, (hwc_ioctls_t *) arg))
  2437. goto fault;
  2438. break;
  2439. #endif
  2441. default:
  2442. goto noioctlcmd;
  2443. }
  2445. if (_IOC_DIR (cmd) == _IOC_WRITE)
  2446. retval = set_hwc_ioctls (&tmp, 0);
  2448. goto out;
  2450.       fault:
  2451. retval = -EFAULT;
  2452. goto out;
  2453.       noioctlcmd:
  2454. retval = -ENOIOCTLCMD;
  2455.       out:
  2456. spin_unlock_irqrestore (&hwc_data.lock, flags);
  2457. return retval;
  2458. }