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

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

Linux/Unix编程

开发平台：

Unix_Linux

ioctl.c：源码内容
  1. /*
  2.  * Copyright (C) 1996  SpellCaster Telecommunications Inc.
  3.  *
  4.  * This software may be used and distributed according to the terms
  5.  * of the GNU General Public License, incorporated herein by reference.
  6.  *
  7.  */
  9. #define __NO_VERSION__
  10. #include "includes.h"
  11. #include "hardware.h"
  12. #include "message.h"
  13. #include "card.h"
  14. #include "scioc.h"
  16. extern int indicate_status(int, int, unsigned long, char *);
  17. extern int startproc(int);
  18. extern int loadproc(int, char *record);
  19. extern int reset(int);
  20. extern int send_and_receive(int, unsigned int, unsigned char,unsigned char,
  21. unsigned char,unsigned char, 
  22. unsigned char, unsigned char *, RspMessage *, int);
  24. extern board *adapter[];
  27. int GetStatus(int card, boardInfo *);
  29. /*
  30.  * Process private IOCTL messages (typically from scctrl)
  31.  */
  32. int sc_ioctl(int card, scs_ioctl *data)
  33. {
  34. switch(data->command) {
  35. case SCIOCRESET: /* Perform a hard reset of the adapter */
  36. {
  37. pr_debug("%s: SCIOCRESET: ioctl receivedn", adapter[card]->devicename);
  38. adapter[card]->StartOnReset = 0;
  39. return (reset(card));
  40. }
  42. case SCIOCLOAD:
  43. {
  44. RspMessage rcvmsg;
  45. char srec[SCIOC_SRECSIZE];
  46. int status, err;
  48. pr_debug("%s: SCIOLOAD: ioctl receivedn", adapter[card]->devicename);
  49. if(adapter[card]->EngineUp) {
  50. pr_debug("%s: SCIOCLOAD: command failed, LoadProc while engine running.n",
  51. adapter[card]->devicename);
  52. return -1;
  53. }
  55. /*
  56.  * Get the SRec from user space
  57.  */
  58. if ((err = copy_from_user(srec, (char *) data->dataptr, sizeof(srec))))
  59. return err;
  61. status = send_and_receive(card, CMPID, cmReqType2, cmReqClass0, cmReqLoadProc,
  62. 0, sizeof(srec), srec, &rcvmsg, SAR_TIMEOUT);
  63. if(status) {
  64. pr_debug("%s: SCIOCLOAD: command failed, status = %dn", 
  65. adapter[card]->devicename, status);
  66. return -1;
  67. }
  68. else {
  69. pr_debug("%s: SCIOCLOAD: command successfuln", adapter[card]->devicename);
  70. return 0;
  71. }
  72. }
  74. case SCIOCSTART:
  75. {
  76. pr_debug("%s: SCIOSTART: ioctl receivedn", adapter[card]->devicename);
  77. if(adapter[card]->EngineUp) {
  78. pr_debug("%s: SCIOCSTART: command failed, engine already running.n",
  79. adapter[card]->devicename);
  80. return -1;
  81. }
  83. adapter[card]->StartOnReset = 1;
  84. startproc(card);
  85. return 0;
  86. }
  88. case SCIOCSETSWITCH:
  89. {
  90. RspMessage rcvmsg;
  91. char switchtype;
  92. int  status, err;
  94. pr_debug("%s: SCIOSETSWITCH: ioctl receivedn", adapter[card]->devicename);
  96. /*
  97.  * Get the switch type from user space
  98.  */
  99. if ((err = copy_from_user(&switchtype, (char *) data->dataptr, sizeof(char))))
  100. return err;
  102. pr_debug("%s: SCIOCSETSWITCH: setting switch type to %dn", adapter[card]->devicename,
  103. switchtype);
  104. status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallSetSwitchType,
  105. 0, sizeof(char),&switchtype,&rcvmsg, SAR_TIMEOUT);
  106. if(!status && !rcvmsg.rsp_status) {
  107. pr_debug("%s: SCIOCSETSWITCH: command successfuln", adapter[card]->devicename);
  108. return 0;
  109. }
  110. else {
  111. pr_debug("%s: SCIOCSETSWITCH: command failed (status = %d)n",
  112. adapter[card]->devicename, status);
  113. return status;
  114. }
  115. }
  117. case SCIOCGETSWITCH:
  118. {
  119. RspMessage  rcvmsg;
  120. char switchtype;
  121. int status, err;
  123. pr_debug("%s: SCIOGETSWITCH: ioctl receivedn", adapter[card]->devicename);
  125. /*
  126.  * Get the switch type from the board
  127.  */
  128. status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, 
  129. ceReqCallGetSwitchType, 0, 0, 0, &rcvmsg, SAR_TIMEOUT);
  130. if (!status && !rcvmsg.rsp_status) {
  131. pr_debug("%s: SCIOCGETSWITCH: command successfuln", adapter[card]->devicename);
  132. }
  133. else {
  134. pr_debug("%s: SCIOCGETSWITCH: command failed (status = %d)n",
  135. adapter[card]->devicename, status);
  136. return status;
  137. }
  139. switchtype = rcvmsg.msg_data.byte_array[0];
  141. /*
  142.  * Package the switch type and send to user space
  143.  */
  144. if ((err = copy_to_user((char *) data->dataptr, &switchtype, sizeof(char))))
  145. return err;
  147. return 0;
  148. }
  150. case SCIOCGETSPID:
  151. {
  152. RspMessage rcvmsg;
  153. char spid[SCIOC_SPIDSIZE];
  154. int status, err;
  156. pr_debug("%s: SCIOGETSPID: ioctl receivedn", adapter[card]->devicename);
  158. /*
  159.  * Get the spid from the board
  160.  */
  161. status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallGetSPID,
  162. data->channel, 0, 0, &rcvmsg, SAR_TIMEOUT);
  163. if (!status) {
  164. pr_debug("%s: SCIOCGETSPID: command successfuln", adapter[card]->devicename);
  165. }
  166. else {
  167. pr_debug("%s: SCIOCGETSPID: command failed (status = %d)n",
  168. adapter[card]->devicename, status);
  169. return status;
  170. }
  171. strcpy(spid, rcvmsg.msg_data.byte_array);
  173. /*
  174.  * Package the switch type and send to user space
  175.  */
  176. if ((err = copy_to_user((char *) data->dataptr, spid, sizeof(spid))))
  177. return err;
  179. return 0;
  180. }
  182. case SCIOCSETSPID:
  183. {
  184. RspMessage rcvmsg;
  185. char spid[SCIOC_SPIDSIZE];
  186. int  status, err;
  188. pr_debug("%s: DCBIOSETSPID: ioctl receivedn", adapter[card]->devicename);
  190. /*
  191.  * Get the spid from user space
  192.  */
  193. if ((err = copy_from_user(spid, (char *) data->dataptr, sizeof(spid))))
  194. return err;
  196. pr_debug("%s: SCIOCSETSPID: setting channel %d spid to %sn", 
  197. adapter[card]->devicename, data->channel, spid);
  198. status = send_and_receive(card, CEPID, ceReqTypeCall, 
  199. ceReqClass0, ceReqCallSetSPID, data->channel, 
  200. strlen(spid), spid, &rcvmsg, SAR_TIMEOUT);
  201. if(!status && !rcvmsg.rsp_status) {
  202. pr_debug("%s: SCIOCSETSPID: command successfuln", 
  203. adapter[card]->devicename);
  204. return 0;
  205. }
  206. else {
  207. pr_debug("%s: SCIOCSETSPID: command failed (status = %d)n",
  208. adapter[card]->devicename, status);
  209. return status;
  210. }
  211. }
  213. case SCIOCGETDN:
  214. {
  215. RspMessage rcvmsg;
  216. char dn[SCIOC_DNSIZE];
  217. int status, err;
  219. pr_debug("%s: SCIOGETDN: ioctl receivedn", adapter[card]->devicename);
  221. /*
  222.  * Get the dn from the board
  223.  */
  224. status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallGetMyNumber,
  225. data->channel, 0, 0, &rcvmsg, SAR_TIMEOUT);
  226. if (!status) {
  227. pr_debug("%s: SCIOCGETDN: command successfuln", adapter[card]->devicename);
  228. }
  229. else {
  230. pr_debug("%s: SCIOCGETDN: command failed (status = %d)n",
  231. adapter[card]->devicename, status);
  232. return status;
  233. }
  235. strcpy(dn, rcvmsg.msg_data.byte_array);
  237. /*
  238.  * Package the dn and send to user space
  239.  */
  240. if ((err = copy_to_user((char *) data->dataptr, dn, sizeof(dn))))
  241. return err;
  243. return 0;
  244. }
  246. case SCIOCSETDN:
  247. {
  248. RspMessage rcvmsg;
  249. char dn[SCIOC_DNSIZE];
  250. int  status, err;
  252. pr_debug("%s: SCIOSETDN: ioctl receivedn", adapter[card]->devicename);
  254. /*
  255.  * Get the spid from user space
  256.  */
  257. if ((err = copy_from_user(dn, (char *) data->dataptr, sizeof(dn))))
  258. return err;
  260. pr_debug("%s: SCIOCSETDN: setting channel %d dn to %sn", 
  261. adapter[card]->devicename, data->channel, dn);
  262. status = send_and_receive(card, CEPID, ceReqTypeCall, 
  263. ceReqClass0, ceReqCallSetMyNumber, data->channel, 
  264. strlen(dn),dn,&rcvmsg, SAR_TIMEOUT);
  265. if(!status && !rcvmsg.rsp_status) {
  266. pr_debug("%s: SCIOCSETDN: command successfuln", 
  267. adapter[card]->devicename);
  268. return 0;
  269. }
  270. else {
  271. pr_debug("%s: SCIOCSETDN: command failed (status = %d)n",
  272. adapter[card]->devicename, status);
  273. return status;
  274. }
  275. }
  277. case SCIOCTRACE:
  279. pr_debug("%s: SCIOTRACE: ioctl receivedn", adapter[card]->devicename);
  280. /* adapter[card]->trace = !adapter[card]->trace; 
  281. pr_debug("%s: SCIOCTRACE: tracing turned %sn", adapter[card]->devicename,
  282. adapter[card]->trace ? "ON" : "OFF"); */
  283. break;
  285. case SCIOCSTAT:
  286. {
  287. boardInfo bi;
  288. int err;
  290. pr_debug("%s: SCIOSTAT: ioctl receivedn", adapter[card]->devicename);
  291. GetStatus(card, &bi);
  293. if ((err = copy_to_user((boardInfo *) data->dataptr, &bi, sizeof(boardInfo))))
  294. return err;
  296. return 0;
  297. }
  299. case SCIOCGETSPEED:
  300. {
  301. RspMessage rcvmsg;
  302. char speed;
  303. int status, err;
  305. pr_debug("%s: SCIOGETSPEED: ioctl receivedn", adapter[card]->devicename);
  307. /*
  308.  * Get the speed from the board
  309.  */
  310. status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, 
  311. ceReqCallGetCallType, data->channel, 0, 0, &rcvmsg, SAR_TIMEOUT);
  312. if (!status && !rcvmsg.rsp_status) {
  313. pr_debug("%s: SCIOCGETSPEED: command successfuln",
  314. adapter[card]->devicename);
  315. }
  316. else {
  317. pr_debug("%s: SCIOCGETSPEED: command failed (status = %d)n",
  318. adapter[card]->devicename, status);
  319. return status;
  320. }
  322. speed = rcvmsg.msg_data.byte_array[0];
  324. /*
  325.  * Package the switch type and send to user space
  326.  */
  327. if ((err = copy_to_user((char *) data->dataptr, &speed, sizeof(char))))
  328. return err;
  330. return 0;
  331. }
  333. case SCIOCSETSPEED:
  334. pr_debug("%s: SCIOCSETSPEED: ioctl receivedn", adapter[card]->devicename);
  335. break;
  337. case SCIOCLOOPTST:
  338. pr_debug("%s: SCIOCLOOPTST: ioctl receivedn", adapter[card]->devicename);
  339. break;
  341. default:
  342. return -1;
  343. }
  345. return 0;
  346. }
  348. int GetStatus(int card, boardInfo *bi)
  349. {
  350. RspMessage rcvmsg;
  351. int i, status;
  353. /*
  354.  * Fill in some of the basic info about the board
  355.  */
  356. bi->modelid = adapter[card]->model;
  357. strcpy(bi->serial_no, adapter[card]->hwconfig.serial_no);
  358. strcpy(bi->part_no, adapter[card]->hwconfig.part_no);
  359. bi->iobase = adapter[card]->iobase;
  360. bi->rambase = adapter[card]->rambase;
  361. bi->irq = adapter[card]->interrupt;
  362. bi->ramsize = adapter[card]->hwconfig.ram_size;
  363. bi->interface = adapter[card]->hwconfig.st_u_sense;
  364. strcpy(bi->load_ver, adapter[card]->load_ver);
  365. strcpy(bi->proc_ver, adapter[card]->proc_ver);
  367. /*
  368.  * Get the current PhyStats and LnkStats
  369.  */
  370. status = send_and_receive(card, CEPID, ceReqTypePhy, ceReqClass2,
  371. ceReqPhyStatus, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT);
  372. if(!status) {
  373. if(adapter[card]->model < PRI_BOARD) {
  374. bi->l1_status = rcvmsg.msg_data.byte_array[2];
  375. for(i = 0 ; i < BRI_CHANNELS ; i++)
  376. bi->status.bristats[i].phy_stat =
  377. rcvmsg.msg_data.byte_array[i];
  378. }
  379. else {
  380. bi->l1_status = rcvmsg.msg_data.byte_array[0];
  381. bi->l2_status = rcvmsg.msg_data.byte_array[1];
  382. for(i = 0 ; i < PRI_CHANNELS ; i++)
  383. bi->status.pristats[i].phy_stat = 
  384. rcvmsg.msg_data.byte_array[i+2];
  385. }
  386. }
  388. /*
  389.  * Get the call types for each channel
  390.  */
  391. for (i = 0 ; i < adapter[card]->nChannels ; i++) {
  392. status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0,
  393. ceReqCallGetCallType, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT);
  394. if(!status) {
  395. if (adapter[card]->model == PRI_BOARD) {
  396. bi->status.pristats[i].call_type = 
  397. rcvmsg.msg_data.byte_array[0];
  398. }
  399. else {
  400. bi->status.bristats[i].call_type =
  401. rcvmsg.msg_data.byte_array[0];
  402. }
  403. }
  404. }
  406. /*
  407.  * If PRI, get the call states and service states for each channel
  408.  */
  409. if (adapter[card]->model == PRI_BOARD) {
  410. /*
  411.  * Get the call states
  412.  */
  413. status = send_and_receive(card, CEPID, ceReqTypeStat, ceReqClass2,
  414. ceReqPhyChCallState, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT);
  415. if(!status) {
  416. for( i = 0 ; i < PRI_CHANNELS ; i++ )
  417. bi->status.pristats[i].call_state = 
  418. rcvmsg.msg_data.byte_array[i];
  419. }
  421. /*
  422.  * Get the service states
  423.  */
  424. status = send_and_receive(card, CEPID, ceReqTypeStat, ceReqClass2,
  425. ceReqPhyChServState, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT);
  426. if(!status) {
  427. for( i = 0 ; i < PRI_CHANNELS ; i++ )
  428. bi->status.pristats[i].serv_state = 
  429. rcvmsg.msg_data.byte_array[i];
  430. }
  432. /*
  433.  * Get the link stats for the channels
  434.  */
  435. for (i = 1 ; i <= PRI_CHANNELS ; i++) {
  436. status = send_and_receive(card, CEPID, ceReqTypeLnk, ceReqClass0,
  437. ceReqLnkGetStats, i, 0, NULL, &rcvmsg, SAR_TIMEOUT);
  438. if (!status) {
  439. bi->status.pristats[i-1].link_stats.tx_good =
  440. (unsigned long)rcvmsg.msg_data.byte_array[0];
  441. bi->status.pristats[i-1].link_stats.tx_bad =
  442. (unsigned long)rcvmsg.msg_data.byte_array[4];
  443. bi->status.pristats[i-1].link_stats.rx_good =
  444. (unsigned long)rcvmsg.msg_data.byte_array[8];
  445. bi->status.pristats[i-1].link_stats.rx_bad =
  446. (unsigned long)rcvmsg.msg_data.byte_array[12];
  447. }
  448. }
  450. /*
  451.  * Link stats for the D channel
  452.  */
  453. status = send_and_receive(card, CEPID, ceReqTypeLnk, ceReqClass0,
  454. ceReqLnkGetStats, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT);
  455. if (!status) {
  456. bi->dch_stats.tx_good = (unsigned long)rcvmsg.msg_data.byte_array[0];
  457. bi->dch_stats.tx_bad = (unsigned long)rcvmsg.msg_data.byte_array[4];
  458. bi->dch_stats.rx_good = (unsigned long)rcvmsg.msg_data.byte_array[8];
  459. bi->dch_stats.rx_bad = (unsigned long)rcvmsg.msg_data.byte_array[12];
  460. }
  462. return 0;
  463. }
  465. /*
  466.  * If BRI or POTS, Get SPID, DN and call types for each channel
  467.  */
  469. /*
  470.  * Get the link stats for the channels
  471.  */
  472. status = send_and_receive(card, CEPID, ceReqTypeLnk, ceReqClass0,
  473. ceReqLnkGetStats, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT);
  474. if (!status) {
  475. bi->dch_stats.tx_good = (unsigned long)rcvmsg.msg_data.byte_array[0];
  476. bi->dch_stats.tx_bad = (unsigned long)rcvmsg.msg_data.byte_array[4];
  477. bi->dch_stats.rx_good = (unsigned long)rcvmsg.msg_data.byte_array[8];
  478. bi->dch_stats.rx_bad = (unsigned long)rcvmsg.msg_data.byte_array[12];
  479. bi->status.bristats[0].link_stats.tx_good = 
  480. (unsigned long)rcvmsg.msg_data.byte_array[16];
  481. bi->status.bristats[0].link_stats.tx_bad = 
  482. (unsigned long)rcvmsg.msg_data.byte_array[20];
  483. bi->status.bristats[0].link_stats.rx_good = 
  484. (unsigned long)rcvmsg.msg_data.byte_array[24];
  485. bi->status.bristats[0].link_stats.rx_bad = 
  486. (unsigned long)rcvmsg.msg_data.byte_array[28];
  487. bi->status.bristats[1].link_stats.tx_good = 
  488. (unsigned long)rcvmsg.msg_data.byte_array[32];
  489. bi->status.bristats[1].link_stats.tx_bad = 
  490. (unsigned long)rcvmsg.msg_data.byte_array[36];
  491. bi->status.bristats[1].link_stats.rx_good = 
  492. (unsigned long)rcvmsg.msg_data.byte_array[40];
  493. bi->status.bristats[1].link_stats.rx_bad = 
  494. (unsigned long)rcvmsg.msg_data.byte_array[44];
  495. }
  497. /*
  498.  * Get the SPIDs
  499.  */
  500. for (i = 0 ; i < BRI_CHANNELS ; i++) {
  501. status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0,
  502. ceReqCallGetSPID, i+1, 0, NULL, &rcvmsg, SAR_TIMEOUT);
  503. if (!status)
  504. strcpy(bi->status.bristats[i].spid, rcvmsg.msg_data.byte_array);
  505. }
  507. /*
  508.  * Get the DNs
  509.  */
  510. for (i = 0 ; i < BRI_CHANNELS ; i++) {
  511. status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0,
  512. ceReqCallGetMyNumber, i+1, 0, NULL, &rcvmsg, SAR_TIMEOUT);
  513. if (!status)
  514. strcpy(bi->status.bristats[i].dn, rcvmsg.msg_data.byte_array);
  515. }
  517. return 0;
  518. }