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

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

嵌入式Linux

开发平台：

Unix_Linux

riotable.c：源码内容
  1. /*
  2. ** -----------------------------------------------------------------------------
  3. **
  4. **  Perle Specialix driver for Linux
  5. **  Ported from existing RIO Driver for SCO sources.
  6.  *
  7.  *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
  8.  *
  9.  *      This program is free software; you can redistribute it and/or modify
  10.  *      it under the terms of the GNU General Public License as published by
  11.  *      the Free Software Foundation; either version 2 of the License, or
  12.  *      (at your option) any later version.
  13.  *
  14.  *      This program is distributed in the hope that it will be useful,
  15.  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  *      GNU General Public License for more details.
  18.  *
  19.  *      You should have received a copy of the GNU General Public License
  20.  *      along with this program; if not, write to the Free Software
  21.  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22. **
  23. ** Module : riotable.c
  24. ** SID : 1.2
  25. ** Last Modified : 11/6/98 10:33:47
  26. ** Retrieved : 11/6/98 10:33:50
  27. **
  28. **  ident @(#)riotable.c 1.2
  29. **
  30. ** -----------------------------------------------------------------------------
  31. */
  32. #ifdef SCCS_LABELS
  33. static char *_riotable_c_sccs_ = "@(#)riotable.c 1.2";
  34. #endif
  36. #define __NO_VERSION__
  37. #include <linux/module.h>
  38. #include <linux/slab.h>
  39. #include <linux/errno.h>
  40. #include <linux/interrupt.h>
  42. #include <asm/io.h>
  43. #include <asm/system.h>
  44. #include <asm/string.h>
  45. #include <asm/semaphore.h>
  46. #include <asm/uaccess.h>
  48. #include <linux/termios.h>
  49. #include <linux/serial.h>
  51. #include <linux/compatmac.h>
  52. #include <linux/generic_serial.h>
  55. #include "linux_compat.h"
  56. #include "rio_linux.h"
  57. #include "typdef.h"
  58. #include "pkt.h"
  59. #include "daemon.h"
  60. #include "rio.h"
  61. #include "riospace.h"
  62. #include "top.h"
  63. #include "cmdpkt.h"
  64. #include "map.h"
  65. #include "riotypes.h"
  66. #include "rup.h"
  67. #include "port.h"
  68. #include "riodrvr.h"
  69. #include "rioinfo.h"
  70. #include "func.h"
  71. #include "errors.h"
  72. #include "pci.h"
  74. #include "parmmap.h"
  75. #include "unixrup.h"
  76. #include "board.h"
  77. #include "host.h"
  78. #include "error.h"
  79. #include "phb.h"
  80. #include "link.h"
  81. #include "cmdblk.h"
  82. #include "route.h"
  83. #include "control.h"
  84. #include "cirrus.h"
  85. #include "rioioctl.h"
  86. #include "param.h"
  87. #include "list.h"
  88. #include "sam.h"
  89. #include "protsts.h"
  91. /*
  92. ** A configuration table has been loaded. It is now up to us
  93. ** to sort it out and use the information contained therein.
  94. */
  95. int
  96. RIONewTable(p)
  97. struct rio_info * p;
  98. {
  99. int Host, Host1, Host2, NameIsUnique, Entry, SubEnt;
  100. struct Map *MapP;
  101. struct Map *HostMapP;
  102. struct Host *HostP;
  104. char *cptr;
  106. /*
  107. ** We have been sent a new table to install. We need to break
  108. ** it down into little bits and spread it around a bit to see
  109. ** what we have got.
  110. */
  111. /*
  112. ** Things to check:
  113. ** (things marked 'xx' aren't checked any more!)
  114. ** (1) That there are no booted Hosts/RTAs out there.
  115. ** (2) That the names are properly formed
  116. ** (3) That blank entries really are.
  117. ** xx (4) That hosts mentioned in the table actually exist. xx
  118. ** (5) That the IDs are unique (per host).
  119. ** (6) That host IDs are zero
  120. ** (7) That port numbers are valid
  121. ** (8) That port numbers aren't duplicated
  122. ** (9) That names aren't duplicated
  123. ** xx (10) That hosts that actually exist are mentioned in the table. xx
  124. */
  125. rio_dprintk (RIO_DEBUG_TABLE, "RIONewTable: entering(1)n"); 
  126. if ( p->RIOSystemUp ) { /* (1) */
  127. p->RIOError.Error = HOST_HAS_ALREADY_BEEN_BOOTED;
  128. return EBUSY;
  129. }
  131. p->RIOError.Error = NOTHING_WRONG_AT_ALL;
  132. p->RIOError.Entry = -1;
  133. p->RIOError.Other = -1;
  135. for ( Entry=0; Entry<TOTAL_MAP_ENTRIES; Entry++ ) {
  136. MapP = &p->RIOConnectTable[Entry];
  137. if ((MapP->Flags & RTA16_SECOND_SLOT) == 0) {
  138. rio_dprintk (RIO_DEBUG_TABLE, "RIONewTable: entering(2)n");
  139. cptr = MapP->Name; /* (2) */
  140. cptr[MAX_NAME_LEN-1]='';
  141. if ( cptr[0]=='' ) {
  142. bcopy(MapP->RtaUniqueNum?"RTA NN":"HOST NN",MapP->Name,8);
  143. MapP->Name[5] = '0'+Entry/10;
  144. MapP->Name[6] = '0'+Entry%10;
  145. }
  146. while ( *cptr ) {
  147. if ( *cptr<' ' || *cptr>'~' ) {
  148. p->RIOError.Error = BAD_CHARACTER_IN_NAME;
  149. p->RIOError.Entry = Entry;
  150. return ENXIO;
  151. }
  152. cptr++;
  153. }
  154. }
  156. /*
  157. ** If the entry saved was a tentative entry then just forget
  158. ** about it.
  159. */
  160. if ( MapP->Flags & SLOT_TENTATIVE ) {
  161. MapP->HostUniqueNum = 0;
  162. MapP->RtaUniqueNum = 0;
  163. continue;
  164. }
  166. rio_dprintk (RIO_DEBUG_TABLE, "RIONewTable: entering(3)n");
  167. if ( !MapP->RtaUniqueNum && !MapP->HostUniqueNum ) { /* (3) */
  168. if ( MapP->ID || MapP->SysPort || MapP->Flags ) {
  169. rio_dprintk (RIO_DEBUG_TABLE, "%s pretending to be empty but isn'tn",MapP->Name);
  170. p->RIOError.Error = TABLE_ENTRY_ISNT_PROPERLY_NULL;
  171. p->RIOError.Entry = Entry;
  172. return ENXIO;
  173. }
  174. rio_dprintk (RIO_DEBUG_TABLE, "!RIO: Daemon: test (3) passesn");
  175. continue;
  176. }
  178. rio_dprintk (RIO_DEBUG_TABLE, "RIONewTable: entering(4)n");
  179. for ( Host=0; Host<p->RIONumHosts; Host++ ) { /* (4) */
  180. if ( p->RIOHosts[Host].UniqueNum==MapP->HostUniqueNum ) {
  181. HostP = &p->RIOHosts[Host];
  182. /*
  183. ** having done the lookup, we don't really want to do
  184. ** it again, so hang the host number in a safe place
  185. */
  186. MapP->Topology[0].Unit = Host;
  187. break;
  188. }
  189. }
  191. if ( Host >= p->RIONumHosts ) {
  192. rio_dprintk (RIO_DEBUG_TABLE, "RTA %s has unknown host unique number 0x%xn",
  193. MapP->Name, MapP->HostUniqueNum);
  194. MapP->HostUniqueNum = 0;
  195. /* MapP->RtaUniqueNum = 0; */
  196. /* MapP->ID = 0; */
  197. /* MapP->Flags  = 0; */
  198. /* MapP->SysPort  = 0; */
  199. /* MapP->Name[0]  = 0; */
  200. continue;
  201. }
  203. rio_dprintk (RIO_DEBUG_TABLE, "RIONewTable: entering(5)n"); 
  204. if ( MapP->RtaUniqueNum ) { /* (5) */
  205. if ( !MapP->ID ) {
  206. rio_dprintk (RIO_DEBUG_TABLE, "RIO: RTA %s has been allocated an ID of zero!n",
  207. MapP->Name);
  208. p->RIOError.Error  = ZERO_RTA_ID;
  209. p->RIOError.Entry = Entry;
  210. return ENXIO;
  211. }
  212. if ( MapP->ID > MAX_RUP ) {
  213. rio_dprintk (RIO_DEBUG_TABLE, "RIO: RTA %s has been allocated an illegal ID %dn",
  214. MapP->Name, MapP->ID);
  215. p->RIOError.Error = ID_NUMBER_OUT_OF_RANGE;
  216. p->RIOError.Entry = Entry;
  217. return ENXIO;
  218. }
  219. for ( SubEnt=0; SubEnt<Entry; SubEnt++ ) {
  220. if ( MapP->HostUniqueNum == 
  221. p->RIOConnectTable[SubEnt].HostUniqueNum && 
  222. MapP->ID == p->RIOConnectTable[SubEnt].ID ) {
  223. rio_dprintk (RIO_DEBUG_TABLE, "Dupl. ID number allocated to RTA %s and RTA %sn",
  224. MapP->Name, p->RIOConnectTable[SubEnt].Name);
  225. p->RIOError.Error = DUPLICATED_RTA_ID;
  226. p->RIOError.Entry = Entry;
  227. p->RIOError.Other = SubEnt;
  228. return ENXIO;
  229. }
  230. /*
  231. ** If the RtaUniqueNum is the same, it may be looking at both
  232. ** entries for a 16 port RTA, so check the ids
  233. */
  234. if ((MapP->RtaUniqueNum == 
  235. p->RIOConnectTable[SubEnt].RtaUniqueNum)
  236.   && (MapP->ID2 != p->RIOConnectTable[SubEnt].ID)) {
  237. rio_dprintk (RIO_DEBUG_TABLE, "RTA %s has duplicate unique numbern",MapP->Name);
  238. rio_dprintk (RIO_DEBUG_TABLE, "RTA %s has duplicate unique numbern",
  239. p->RIOConnectTable[SubEnt].Name);
  240. p->RIOError.Error = DUPLICATE_UNIQUE_NUMBER;
  241. p->RIOError.Entry = Entry;
  242. p->RIOError.Other = SubEnt;
  243. return ENXIO;
  244. }
  245. }
  246. rio_dprintk (RIO_DEBUG_TABLE, "RIONewTable: entering(7a)n"); 
  247. /* (7a) */
  248. if ((MapP->SysPort != NO_PORT)&&(MapP->SysPort % PORTS_PER_RTA)) {
  249. rio_dprintk (RIO_DEBUG_TABLE, "TTY Port number %d-RTA %s is not a multiple of %d!n",
  250. (int)MapP->SysPort,MapP->Name, PORTS_PER_RTA);
  251. p->RIOError.Error = TTY_NUMBER_OUT_OF_RANGE;
  252. p->RIOError.Entry = Entry;
  253. return ENXIO;
  254. }
  255. rio_dprintk (RIO_DEBUG_TABLE, "RIONewTable: entering(7b)n"); 
  256. /* (7b) */
  257. if ((MapP->SysPort != NO_PORT)&&(MapP->SysPort >= RIO_PORTS)) {
  258. rio_dprintk (RIO_DEBUG_TABLE, "TTY Port number %d for RTA %s is too bign",
  259. (int)MapP->SysPort, MapP->Name);
  260. p->RIOError.Error = TTY_NUMBER_OUT_OF_RANGE;
  261. p->RIOError.Entry = Entry;
  262. return ENXIO;
  263. }
  264. for ( SubEnt=0; SubEnt<Entry; SubEnt++ ) {
  265. if ( p->RIOConnectTable[SubEnt].Flags & RTA16_SECOND_SLOT )
  266. continue;
  267. if ( p->RIOConnectTable[SubEnt].RtaUniqueNum ) {
  268. rio_dprintk (RIO_DEBUG_TABLE, "RIONewTable: entering(8)n"); 
  269. /* (8) */
  270. if ( (MapP->SysPort != NO_PORT) && (MapP->SysPort == 
  271. p->RIOConnectTable[SubEnt].SysPort) ) {
  272. rio_dprintk (RIO_DEBUG_TABLE, "RTA %s:same TTY port # as RTA %s (%d)n",
  273. MapP->Name, p->RIOConnectTable[SubEnt].Name,
  274. (int)MapP->SysPort);
  275. p->RIOError.Error = TTY_NUMBER_IN_USE;
  276. p->RIOError.Entry = Entry;
  277. p->RIOError.Other = SubEnt;
  278. return ENXIO;
  279. }
  280. rio_dprintk (RIO_DEBUG_TABLE, "RIONewTable: entering(9)n"); 
  281. if (RIOStrCmp(MapP->Name,
  282. p->RIOConnectTable[SubEnt].Name)==0 && !(MapP->Flags & RTA16_SECOND_SLOT)) { /* (9) */
  283. rio_dprintk (RIO_DEBUG_TABLE, "RTA name %s used twicen", MapP->Name);
  284. p->RIOError.Error = NAME_USED_TWICE;
  285. p->RIOError.Entry = Entry;
  286. p->RIOError.Other = SubEnt;
  287. return ENXIO;
  288. }
  289. }
  290. }
  291. }
  292. else { /* (6) */
  293. rio_dprintk (RIO_DEBUG_TABLE, "RIONewTable: entering(6)n"); 
  294. if ( MapP->ID ) {
  295. rio_dprintk (RIO_DEBUG_TABLE, "RIO:HOST %s has been allocated ID that isn't zero!n",
  296. MapP->Name);
  297. p->RIOError.Error = HOST_ID_NOT_ZERO;
  298. p->RIOError.Entry = Entry;
  299. return ENXIO;
  300. }
  301. if ( MapP->SysPort != NO_PORT ) {
  302. rio_dprintk (RIO_DEBUG_TABLE, "RIO: HOST %s has been allocated port numbers!n",
  303. MapP->Name);
  304. p->RIOError.Error = HOST_SYSPORT_BAD;
  305. p->RIOError.Entry = Entry;
  306. return ENXIO;
  307. }
  308. }
  309. }
  311. /*
  312. ** wow! if we get here then its a goody!
  313. */
  315. /*
  316. ** Zero the (old) entries for each host...
  317. */
  318. for ( Host=0; Host<RIO_HOSTS; Host++ ) {
  319. for ( Entry=0; Entry<MAX_RUP; Entry++ ) {
  320. bzero((caddr_t)&p->RIOHosts[Host].Mapping[Entry], 
  321. sizeof(struct Map));
  322. }
  323. bzero((caddr_t)&p->RIOHosts[Host].Name[0],
  324. sizeof(p->RIOHosts[Host].Name) );
  325. }
  327. /*
  328. ** Copy in the new table entries
  329. */
  330. for ( Entry=0; Entry< TOTAL_MAP_ENTRIES; Entry++ ) {
  331. rio_dprintk (RIO_DEBUG_TABLE, "RIONewTable: Copy table for Host entry %dn", Entry);
  332. MapP = &p->RIOConnectTable[Entry];
  334. /*
  335. ** Now, if it is an empty slot ignore it!
  336. */
  337. if ( MapP->HostUniqueNum==0 )
  338. continue;
  340. /*
  341. ** we saved the host number earlier, so grab it back
  342. */
  343. HostP = &p->RIOHosts[MapP->Topology[0].Unit];
  345. /*
  346. ** If it is a host, then we only need to fill in the name field.
  347. */
  348. if ( MapP->ID==0 ) {
  349. rio_dprintk (RIO_DEBUG_TABLE, "Host entry found. Name %sn", MapP->Name);
  350. bcopy(MapP->Name,HostP->Name,MAX_NAME_LEN);
  351. continue;
  352. }
  354. /*
  355. ** Its an RTA entry, so fill in the host mapping entries for it
  356. ** and the port mapping entries. Notice that entry zero is for
  357. ** ID one.
  358. */
  359. HostMapP = &HostP->Mapping[MapP->ID-1];
  361. if (MapP->Flags & SLOT_IN_USE) {
  362. rio_dprintk (RIO_DEBUG_TABLE, "Rta entry found. Name %sn", MapP->Name);
  363. /*
  364. ** structure assign, then sort out the bits we shouldn't have done
  365. */
  366. *HostMapP = *MapP;
  368. HostMapP->Flags = SLOT_IN_USE;
  369. if (MapP->Flags & RTA16_SECOND_SLOT)
  370. HostMapP->Flags |= RTA16_SECOND_SLOT;
  372. RIOReMapPorts(p, HostP, HostMapP );
  373. }
  374. else {
  375. rio_dprintk (RIO_DEBUG_TABLE, "TENTATIVE Rta entry found. Name %sn", MapP->Name);
  376. }
  377. }
  379. for ( Entry=0; Entry< TOTAL_MAP_ENTRIES; Entry++ ) {
  380. p->RIOSavedTable[Entry] = p->RIOConnectTable[Entry];
  381. }
  383. for ( Host=0; Host<p->RIONumHosts; Host++ ) {
  384. for ( SubEnt=0; SubEnt<LINKS_PER_UNIT; SubEnt++ ) {
  385. p->RIOHosts[Host].Topology[SubEnt].Unit = ROUTE_DISCONNECT;
  386. p->RIOHosts[Host].Topology[SubEnt].Link = NO_LINK;
  387. }
  388. for ( Entry=0; Entry<MAX_RUP; Entry++ ) {
  389. for ( SubEnt=0; SubEnt<LINKS_PER_UNIT; SubEnt++ ) {
  390. p->RIOHosts[Host].Mapping[Entry].Topology[SubEnt].Unit = 
  391. ROUTE_DISCONNECT;
  392. p->RIOHosts[Host].Mapping[Entry].Topology[SubEnt].Link = 
  393. NO_LINK;
  394. }
  395. }
  396. if ( !p->RIOHosts[Host].Name[0] ) {
  397. bcopy("HOST 1",p->RIOHosts[Host].Name,7);
  398. p->RIOHosts[Host].Name[5] += Host;
  399. }
  400. /*
  401. ** Check that default name assigned is unique.
  402. */
  403. Host1 = Host;
  404. NameIsUnique = 0;
  405. while (!NameIsUnique) {
  406. NameIsUnique = 1;
  407. for ( Host2=0; Host2<p->RIONumHosts; Host2++ ) {
  408. if (Host2 == Host)
  409. continue;
  410. if (RIOStrCmp(p->RIOHosts[Host].Name, p->RIOHosts[Host2].Name)
  411.  == 0) {
  412. NameIsUnique = 0;
  413. Host1++;
  414. if (Host1 >= p->RIONumHosts)
  415. Host1 = 0;
  416. p->RIOHosts[Host].Name[5] = '1' + Host1;
  417. }
  418. }
  419. }
  420. /*
  421. ** Rename host if name already used.
  422. */
  423. if (Host1 != Host)
  424. {
  425. rio_dprintk (RIO_DEBUG_TABLE, "Default name %s already usedn", p->RIOHosts[Host].Name);
  426. bcopy("HOST 1",p->RIOHosts[Host].Name,7);
  427. p->RIOHosts[Host].Name[5] += Host1;
  428. }
  429. rio_dprintk (RIO_DEBUG_TABLE, "Assigning default name %sn", p->RIOHosts[Host].Name);
  430. }
  431. return 0;
  432. }
  434. /*
  435. ** User process needs the config table - build it from first
  436. ** principles.
  437. */
  438. int
  439. RIOApel(p)
  440. struct rio_info * p;
  441. {
  442. int Host;
  443. int link;
  444. int Rup;
  445. int Next = 0;
  446. struct Map *MapP;
  447. struct Host *HostP;
  448. long oldspl;
  450. disable(oldspl); /* strange but true! */
  451.  
  452. rio_dprintk (RIO_DEBUG_TABLE, "Generating a table to return to config.rion");
  454. bzero((caddr_t)&p->RIOConnectTable[0], 
  455. sizeof(struct Map) * TOTAL_MAP_ENTRIES );
  457. for ( Host=0; Host<RIO_HOSTS; Host++ ) {
  458. rio_dprintk (RIO_DEBUG_TABLE, "Processing host %dn", Host);
  459. HostP = &p->RIOHosts[Host];
  460. MapP = &p->RIOConnectTable[Next++];
  461. MapP->HostUniqueNum = HostP->UniqueNum;
  462. if ( (HostP->Flags & RUN_STATE) != RC_RUNNING )
  463. continue;
  464. MapP->RtaUniqueNum = 0;
  465. MapP->ID = 0;
  466. MapP->Flags = SLOT_IN_USE;
  467. MapP->SysPort = NO_PORT;
  468. for ( link=0; link<LINKS_PER_UNIT; link++ )
  469. MapP->Topology[link] = HostP->Topology[link];
  470. bcopy(HostP->Name,MapP->Name,MAX_NAME_LEN);
  471. for ( Rup=0; Rup<MAX_RUP; Rup++ ) {
  472. if ( HostP->Mapping[Rup].Flags & (SLOT_IN_USE|SLOT_TENTATIVE) ) {
  473. p->RIOConnectTable[Next] = HostP->Mapping[Rup];
  474. if ( HostP->Mapping[Rup].Flags & SLOT_IN_USE)
  475. p->RIOConnectTable[Next].Flags |= SLOT_IN_USE;
  476. if ( HostP->Mapping[Rup].Flags & SLOT_TENTATIVE)
  477. p->RIOConnectTable[Next].Flags |= SLOT_TENTATIVE;
  478. if ( HostP->Mapping[Rup].Flags & RTA16_SECOND_SLOT )
  479. p->RIOConnectTable[Next].Flags |= RTA16_SECOND_SLOT;
  480. Next++;
  481. }
  482. }
  483. }
  484. restore(oldspl);
  485. return 0;
  486. }
  488. /*
  489. ** config.rio has taken a dislike to one of the gross maps entries.
  490. ** if the entry is suitably inactive, then we can gob on it and remove
  491. ** it from the table.
  492. */
  493. int
  494. RIODeleteRta(p, MapP)
  495. struct rio_info *p;
  496. struct Map *MapP;
  497. {
  498. int host, entry, port, link;
  499. int SysPort;
  500. struct Host *HostP;
  501. struct Map *HostMapP;
  502. struct Port *PortP;
  503. int work_done = 0;
  504. unsigned long lock_flags, sem_flags;
  506. rio_dprintk (RIO_DEBUG_TABLE, "Delete entry on host %x, rta %xn",
  507. MapP->HostUniqueNum, MapP->RtaUniqueNum);
  509. for ( host=0; host < p->RIONumHosts; host++ ) {
  510. HostP = &p->RIOHosts[host];
  512. rio_spin_lock_irqsave( &HostP->HostLock, lock_flags );
  514. if ( (HostP->Flags & RUN_STATE) != RC_RUNNING ) {
  515. rio_spin_unlock_irqrestore(&HostP->HostLock, lock_flags);
  516. continue;
  517. }
  519. for ( entry=0; entry<MAX_RUP; entry++ ) {
  520. if ( MapP->RtaUniqueNum == HostP->Mapping[entry].RtaUniqueNum ) {
  521. HostMapP = &HostP->Mapping[entry];
  522. rio_dprintk (RIO_DEBUG_TABLE, "Found entry offset %d on host %sn", 
  523. entry, HostP->Name);
  525. /*
  526. ** Check all four links of the unit are disconnected
  527. */
  528. for ( link=0; link< LINKS_PER_UNIT; link++ ) {
  529. if ( HostMapP->Topology[link].Unit != ROUTE_DISCONNECT ) {
  530. rio_dprintk (RIO_DEBUG_TABLE, "Entry is in use and cannot be deleted!n");
  531. p->RIOError.Error = UNIT_IS_IN_USE;
  532. rio_spin_unlock_irqrestore( &HostP->HostLock, lock_flags);
  533. return EBUSY;
  534. }
  535. }
  536. /*
  537. ** Slot has been allocated, BUT not booted/routed/
  538. ** connected/selected or anything else-ed
  539. */
  540. SysPort = HostMapP->SysPort;
  542. if ( SysPort != NO_PORT ) {
  543. for (port=SysPort; port < SysPort+PORTS_PER_RTA; port++) {
  544. PortP = p->RIOPortp[port];
  545. rio_dprintk (RIO_DEBUG_TABLE, "Unmap portn");
  547. rio_spin_lock_irqsave( &PortP->portSem, sem_flags );
  549. PortP->Mapped = 0;
  551. if ( PortP->State & (RIO_MOPEN|RIO_LOPEN) ) {
  553. rio_dprintk (RIO_DEBUG_TABLE, "Gob on portn");
  554. PortP->TxBufferIn = PortP->TxBufferOut = 0;
  555. /* What should I do 
  556. wakeup( &PortP->TxBufferIn );
  557. wakeup( &PortP->TxBufferOut);
  558. */
  559. PortP->InUse = NOT_INUSE;
  560. /* What should I do 
  561. wakeup( &PortP->InUse );
  562. signal(PortP->TtyP->t_pgrp,SIGKILL);
  563. ttyflush(PortP->TtyP,(FREAD|FWRITE));
  564. */
  565. PortP->State |= RIO_CLOSING | RIO_DELETED;
  566. }
  568. /*
  569. ** For the second slot of a 16 port RTA, the
  570. ** driver needs to reset the changes made to
  571. ** the phb to port mappings in RIORouteRup.
  572. */
  573. if (PortP->SecondBlock) {
  574. ushort dest_unit = HostMapP->ID;
  575. ushort dest_port = port - SysPort;
  576. WORD  *TxPktP;
  577. PKT *Pkt;
  579. for (TxPktP = PortP->TxStart;
  580. TxPktP <= PortP->TxEnd; TxPktP++) {
  581. /*
  582. ** *TxPktP is the pointer to the
  583. ** transmit packet on the host card.
  584. ** This needs to be translated into
  585. ** a 32 bit pointer so it can be
  586. ** accessed from the driver.
  587. */
  588. Pkt = (PKT *) RIO_PTR(HostP->Caddr,
  589.   RWORD(*TxPktP));
  590. rio_dprintk (RIO_DEBUG_TABLE, 
  591. "Tx packet (%x) destination: Old %x:%x New %x:%xn",
  592.  *TxPktP, Pkt->dest_unit,
  593.  Pkt->dest_port, dest_unit, dest_port);
  594. WWORD(Pkt->dest_unit, dest_unit);
  595. WWORD(Pkt->dest_port, dest_port);
  596. }
  597. rio_dprintk (RIO_DEBUG_TABLE, 
  598. "Port %d phb destination: Old %x:%x New %x:%xn",
  599.  port, PortP->PhbP->destination & 0xff,
  600.  (PortP->PhbP->destination >> 8) & 0xff,
  601.  dest_unit, dest_port);
  602. WWORD(PortP->PhbP->destination,
  603.  dest_unit + (dest_port << 8));
  604. }
  605. rio_spin_unlock_irqrestore(&PortP->portSem, sem_flags);
  606. }
  607. }
  608. rio_dprintk (RIO_DEBUG_TABLE, "Entry nulled.n");
  609. bzero((char *)HostMapP,sizeof(struct Map));
  610. work_done++;
  611. }
  612. }
  613. rio_spin_unlock_irqrestore(&HostP->HostLock, lock_flags);
  614. }
  616. /* XXXXX lock me up */
  617. for ( entry=0; entry< TOTAL_MAP_ENTRIES; entry++ ) {
  618. if ( p->RIOSavedTable[entry].RtaUniqueNum == MapP->RtaUniqueNum ) {
  619. bzero((char *)&p->RIOSavedTable[entry],sizeof(struct Map));
  620. work_done++;
  621. }
  622. if ( p->RIOConnectTable[entry].RtaUniqueNum == MapP->RtaUniqueNum ) {
  623. bzero((char *)&p->RIOConnectTable[entry],sizeof(struct Map));
  624. work_done++;
  625. }
  626. }
  627. if ( work_done )
  628. return 0;
  630. rio_dprintk (RIO_DEBUG_TABLE, "Couldn't find entry to be deletedn");
  631. p->RIOError.Error = COULDNT_FIND_ENTRY;
  632. return ENXIO;
  633. }
  635. int RIOAssignRta( struct rio_info *p, struct Map *MapP )
  636. {
  637.     int host;
  638.     struct Map *HostMapP;
  639.     char *sptr;
  640.     int link;
  643.     rio_dprintk (RIO_DEBUG_TABLE, "Assign entry on host %x, rta %x, ID %d, Sysport %dn",
  644. MapP->HostUniqueNum,MapP->RtaUniqueNum,
  645. MapP->ID, (int)MapP->SysPort);
  647.     if ((MapP->ID != (ushort)-1) &&
  648. ((int)MapP->ID < (int)1 || (int)MapP->ID > MAX_RUP ))
  649.     {
  650. rio_dprintk (RIO_DEBUG_TABLE, "Bad ID in map entry!n");
  651. p->RIOError.Error = ID_NUMBER_OUT_OF_RANGE;
  652. return EINVAL;
  653.     }
  654.     if (MapP->RtaUniqueNum == 0)
  655.     {
  656. rio_dprintk (RIO_DEBUG_TABLE, "Rta Unique number zero!n");
  657. p->RIOError.Error = RTA_UNIQUE_NUMBER_ZERO;
  658. return EINVAL;
  659.     }
  660.     if ( (MapP->SysPort != NO_PORT) && (MapP->SysPort % PORTS_PER_RTA) )
  661.     {
  662. rio_dprintk (RIO_DEBUG_TABLE, "Port %d not multiple of %d!n",(int)MapP->SysPort,PORTS_PER_RTA);
  663. p->RIOError.Error = TTY_NUMBER_OUT_OF_RANGE;
  664. return EINVAL;
  665.     }
  666.     if ( (MapP->SysPort != NO_PORT) && (MapP->SysPort >= RIO_PORTS) )
  667.     {
  668. rio_dprintk (RIO_DEBUG_TABLE, "Port %d not valid!n",(int)MapP->SysPort);
  669. p->RIOError.Error = TTY_NUMBER_OUT_OF_RANGE;
  670. return EINVAL;
  671.     }
  673.     /*
  674.     ** Copy the name across to the map entry.
  675.     */
  676.     MapP->Name[MAX_NAME_LEN-1] = '';
  677.     sptr = MapP->Name;
  678.     while ( *sptr )
  679.     {
  680.     if ( *sptr<' ' || *sptr>'~' )
  681.     {
  682. rio_dprintk (RIO_DEBUG_TABLE, "Name entry contains non-printing characters!n");
  683. p->RIOError.Error = BAD_CHARACTER_IN_NAME;
  684. return EINVAL;
  685.     }
  686.     sptr++;
  687.     }
  689.     for ( host=0; host < p->RIONumHosts; host++ )
  690.     {
  691. if ( MapP->HostUniqueNum == p->RIOHosts[host].UniqueNum )
  692. {
  693.     if ( (p->RIOHosts[host].Flags & RUN_STATE) != RC_RUNNING )
  694.     {
  695. p->RIOError.Error = HOST_NOT_RUNNING;
  696. return ENXIO;
  697.     }
  699.     /*
  700.     ** Now we have a host we need to allocate an ID
  701.     ** if the entry does not already have one.
  702.     */
  703.     if (MapP->ID == (ushort)-1)
  704.     {
  705. int nNewID;
  707. rio_dprintk (RIO_DEBUG_TABLE, "Attempting to get a new ID for rta "%s"n",
  708.       MapP->Name);
  709. /*
  710. ** The idea here is to allow RTA's to be assigned
  711. ** before they actually appear on the network.
  712. ** This allows the addition of RTA's without having
  713. ** to plug them in.
  714. ** What we do is:
  715. **  - Find a free ID and allocate it to the RTA.
  716. **  - If this map entry is the second half of a
  717. **    16 port entry then find the other half and
  718. **    make sure the 2 cross reference each other.
  719. */
  720. if (RIOFindFreeID(p, &p->RIOHosts[host], &nNewID, NULL) != 0)
  721. {
  722.     p->RIOError.Error = COULDNT_FIND_ENTRY;
  723.     return EBUSY;
  724. }
  725. MapP->ID = (ushort)nNewID + 1;
  726. rio_dprintk (RIO_DEBUG_TABLE, "Allocated ID %d for this new RTA.n", MapP->ID);
  727. HostMapP = &p->RIOHosts[host].Mapping[nNewID];
  728. HostMapP->RtaUniqueNum = MapP->RtaUniqueNum;
  729. HostMapP->HostUniqueNum = MapP->HostUniqueNum;
  730. HostMapP->ID = MapP->ID;
  731. for (link = 0; link < LINKS_PER_UNIT; link++)
  732. {
  733.     HostMapP->Topology[link].Unit = ROUTE_DISCONNECT;
  734.     HostMapP->Topology[link].Link = NO_LINK;
  735. }
  736. if (MapP->Flags & RTA16_SECOND_SLOT)
  737. {
  738.     int unit;
  740.     for (unit = 0; unit < MAX_RUP; unit++)
  741. if (p->RIOHosts[host].Mapping[unit].RtaUniqueNum ==
  742.     MapP->RtaUniqueNum)
  743.     break;
  744.     if (unit == MAX_RUP)
  745.     {
  746. p->RIOError.Error = COULDNT_FIND_ENTRY;
  747. return EBUSY;
  748.     }
  749.     HostMapP->Flags |= RTA16_SECOND_SLOT;
  750.     HostMapP->ID2 = MapP->ID2 = p->RIOHosts[host].Mapping[unit].ID;
  751.     p->RIOHosts[host].Mapping[unit].ID2 = MapP->ID;
  752.     rio_dprintk (RIO_DEBUG_TABLE, "Cross referenced id %d to ID %d.n",
  753.   MapP->ID,
  754.   p->RIOHosts[host].Mapping[unit].ID);
  755. }
  756.     }
  758.     HostMapP = &p->RIOHosts[host].Mapping[MapP->ID-1];
  760.     if ( HostMapP->Flags & SLOT_IN_USE )
  761.     {
  762. rio_dprintk (RIO_DEBUG_TABLE, "Map table slot for ID %d is already in use.n", MapP->ID);
  763. p->RIOError.Error = ID_ALREADY_IN_USE;
  764. return EBUSY;
  765.     }
  767.     /*
  768.     ** Assign the sys ports and the name, and mark the slot as
  769.     ** being in use.
  770.     */
  771.     HostMapP->SysPort = MapP->SysPort;
  772.     if ((MapP->Flags & RTA16_SECOND_SLOT) == 0)
  773.       CCOPY( MapP->Name, HostMapP->Name, MAX_NAME_LEN );
  774.     HostMapP->Flags = SLOT_IN_USE | RTA_BOOTED;
  775. #if NEED_TO_FIX
  776.     RIO_SV_BROADCAST(p->RIOHosts[host].svFlags[MapP->ID-1]);
  777. #endif
  778.     if (MapP->Flags & RTA16_SECOND_SLOT)
  779. HostMapP->Flags |= RTA16_SECOND_SLOT;
  781.     RIOReMapPorts( p, &p->RIOHosts[host], HostMapP );
  782.     /*
  783.     ** Adjust 2nd block of 8 phbs
  784.     */
  785.     if (MapP->Flags & RTA16_SECOND_SLOT)
  786. RIOFixPhbs(p, &p->RIOHosts[host], HostMapP->ID - 1);
  788.     if ( HostMapP->SysPort != NO_PORT )
  789.     {
  790. if ( HostMapP->SysPort < p->RIOFirstPortsBooted )
  791.     p->RIOFirstPortsBooted = HostMapP->SysPort;
  792. if ( HostMapP->SysPort > p->RIOLastPortsBooted )
  793.     p->RIOLastPortsBooted = HostMapP->SysPort;
  794.     }
  795.     if (MapP->Flags & RTA16_SECOND_SLOT)
  796.         rio_dprintk (RIO_DEBUG_TABLE, "Second map of RTA %s added to configurationn",
  797.  p->RIOHosts[host].Mapping[MapP->ID2 - 1].Name);
  798.     else
  799.         rio_dprintk (RIO_DEBUG_TABLE, "RTA %s added to configurationn", MapP->Name);
  800.     return 0;
  801. }
  802.     }
  803.     p->RIOError.Error = UNKNOWN_HOST_NUMBER;
  804.     rio_dprintk (RIO_DEBUG_TABLE, "Unknown host %xn", MapP->HostUniqueNum);
  805.     return ENXIO;
  806. }
  809. int
  810. RIOReMapPorts(p, HostP, HostMapP)
  811. struct rio_info * p;
  812. struct Host *HostP;
  813. struct Map *HostMapP; 
  814. {
  815. register struct Port *PortP;
  816. uint SubEnt;
  817. uint HostPort;
  818. uint SysPort;
  819. ushort RtaType;
  820. unsigned long flags;
  822. #ifdef CHECK
  823. CheckHostP( HostP );
  824. CheckHostMapP( HostMapP );
  825. #endif
  827. rio_dprintk (RIO_DEBUG_TABLE, "Mapping sysport %d to id %dn", (int)HostMapP->SysPort, HostMapP->ID);
  829. /*
  830. ** We need to tell the UnixRups which sysport the rup corresponds to
  831. */
  832. HostP->UnixRups[HostMapP->ID-1].BaseSysPort = HostMapP->SysPort;
  834. if ( HostMapP->SysPort == NO_PORT )
  835. return(0);
  837. RtaType = GetUnitType(HostMapP->RtaUniqueNum);
  838. rio_dprintk (RIO_DEBUG_TABLE, "Mapping sysport %d-%dn",
  839. (int)HostMapP->SysPort, (int)HostMapP->SysPort+PORTS_PER_RTA-1);
  841. /*
  842. ** now map each of its eight ports
  843. */
  844. for ( SubEnt=0; SubEnt<PORTS_PER_RTA; SubEnt++) {
  845.   rio_dprintk (RIO_DEBUG_TABLE, "subent = %d, HostMapP->SysPort = %dn", 
  846.   SubEnt, (int)HostMapP->SysPort);
  847. SysPort = HostMapP->SysPort+SubEnt; /* portnumber within system */
  848. /* portnumber on host */
  850. HostPort = (HostMapP->ID-1)*PORTS_PER_RTA+SubEnt; 
  852. rio_dprintk (RIO_DEBUG_TABLE, "c1 p = %p, p->rioPortp = %pn", p, p->RIOPortp);
  853. PortP = p->RIOPortp[SysPort];
  854. #if 0
  855. PortP->TtyP = &p->channel[SysPort];
  856. #endif
  857. rio_dprintk (RIO_DEBUG_TABLE, "Map portn");
  859. /*
  860. ** Point at all the real neat data structures
  861. */
  862. rio_spin_lock_irqsave(&PortP->portSem, flags);
  863. PortP->HostP = HostP;
  864. PortP->Caddr = HostP->Caddr;
  866. /*
  867. ** The PhbP cannot be filled in yet
  868. ** unless the host has been booted
  869. */
  870. if ((HostP->Flags & RUN_STATE) == RC_RUNNING) {
  871. struct PHB *PhbP = PortP->PhbP = &HostP->PhbP[HostPort];
  872. PortP->TxAdd =(WORD *)RIO_PTR(HostP->Caddr,RWORD(PhbP->tx_add));
  873. PortP->TxStart =(WORD *)RIO_PTR(HostP->Caddr,RWORD(PhbP->tx_start));
  874. PortP->TxEnd =(WORD *)RIO_PTR(HostP->Caddr,RWORD(PhbP->tx_end));
  875. PortP->RxRemove=(WORD *)RIO_PTR(HostP->Caddr,
  876. RWORD(PhbP->rx_remove));
  877. PortP->RxStart =(WORD *)RIO_PTR(HostP->Caddr,RWORD(PhbP->rx_start));
  878. PortP->RxEnd =(WORD *)RIO_PTR(HostP->Caddr,RWORD(PhbP->rx_end));
  879. }
  880. else
  881. PortP->PhbP = NULL;
  883. /*
  884. ** port related flags
  885. */
  886. PortP->HostPort = HostPort;
  887. /*
  888. ** For each part of a 16 port RTA, RupNum is ID - 1.
  889. */
  890. PortP->RupNum = HostMapP->ID - 1;
  891. if (HostMapP->Flags & RTA16_SECOND_SLOT) {
  892. PortP->ID2  = HostMapP->ID2 - 1;
  893. PortP->SecondBlock  = TRUE;
  894. }
  895. else {
  896. PortP->ID2  = 0;
  897. PortP->SecondBlock  = FALSE;
  898. }
  899. PortP->RtaUniqueNum = HostMapP->RtaUniqueNum;
  901. /*
  902. ** If the port was already mapped then thats all we need to do.
  903. */
  904. if (PortP->Mapped) {
  905. rio_spin_unlock_irqrestore( &PortP->portSem, flags);
  906. continue;
  907. }
  908. else HostMapP->Flags &= ~RTA_NEWBOOT;
  910. PortP->State  = 0;
  911. PortP->Config = 0;
  912. /*
  913. ** Check out the module type - if it is special (read only etc.)
  914. ** then we need to set flags in the PortP->Config.
  915. ** Note: For 16 port RTA, all ports are of the same type.
  916. */
  917. if (RtaType == TYPE_RTA16) {
  918. PortP->Config |= p->RIOModuleTypes[HostP->UnixRups
  919. [HostMapP->ID-1].ModTypes].Flags[SubEnt % PORTS_PER_MODULE];
  920. } else {
  921. if ( SubEnt < PORTS_PER_MODULE )
  922. PortP->Config |= p->RIOModuleTypes[LONYBLE(HostP->UnixRups
  923. [HostMapP->ID-1].ModTypes)].Flags[SubEnt % PORTS_PER_MODULE];
  924. else
  925. PortP->Config |= p->RIOModuleTypes[HINYBLE(HostP->UnixRups
  926. [HostMapP->ID-1].ModTypes)].Flags[SubEnt % PORTS_PER_MODULE];
  927. }
  929. /*
  930. ** more port related flags
  931. */
  932. PortP->PortState = 0;
  933. PortP->ModemLines = 0;
  934. PortP->ModemState = 0;
  935. PortP->CookMode = COOK_WELL;
  936. PortP->ParamSem = 0;
  937. PortP->FlushCmdBodge= 0;
  938. PortP->WflushFlag = 0;
  939. PortP->MagicFlags = 0;
  940. PortP->Lock = 0;
  941. PortP->Store = 0;
  942. PortP->FirstOpen = 1;
  944. /*
  945. ** handle the xprint issues
  946. */
  947. #ifdef XPRINT_SUPPORT
  948. PortP->Xprint.XpActive = 0;
  949. PortP->Xprint.XttyP = &riox_tty[SysPort];
  950. /* TO FROM MAXLEN */
  951. RIOStrNCpy( PortP->Xprint.XpOn, RIOConf.XpOn, MAX_XP_CTRL_LEN );
  952. RIOStrNCpy( PortP->Xprint.XpOff, RIOConf.XpOff, MAX_XP_CTRL_LEN );
  953. PortP->Xprint.XpCps = RIOConf.XpCps;
  954. PortP->Xprint.XpLen = RIOStrlen(PortP->Xprint.XpOn)+
  955. RIOStrlen(PortP->Xprint.XpOff);
  956. #endif
  958. /*
  959. ** Buffers 'n things
  960. */
  961. PortP->RxDataStart = 0;
  962. PortP->Cor2Copy  = 0;
  963. PortP->Name  = &HostMapP->Name[0];
  964. #ifdef STATS
  965. bzero( (caddr_t)&PortP->Stat, sizeof(struct RIOStats) );
  966. #endif
  967. PortP->statsGather = 0;
  968. PortP->txchars = 0;
  969. PortP->rxchars = 0;
  970. PortP->opens = 0;
  971. PortP->closes = 0;
  972. PortP->ioctls = 0;
  973. if ( PortP->TxRingBuffer )
  974. bzero( PortP->TxRingBuffer, p->RIOBufferSize );
  975. else if ( p->RIOBufferSize ) {
  976. PortP->TxRingBuffer = sysbrk(p->RIOBufferSize);
  977. bzero( PortP->TxRingBuffer, p->RIOBufferSize );
  978. }
  979. PortP->TxBufferOut = 0;
  980. PortP->TxBufferIn  = 0;
  981. PortP->Debug = 0;
  982. /*
  983. ** LastRxTgl stores the state of the rx toggle bit for this
  984. ** port, to be compared with the state of the next pkt received.
  985. ** If the same, we have received the same rx pkt from the RTA
  986. ** twice. Initialise to a value not equal to PHB_RX_TGL or 0.
  987. */
  988. PortP->LastRxTgl = ~(uchar)PHB_RX_TGL;
  990. /*
  991. ** and mark the port as usable
  992. */
  993. PortP->Mapped = 1;
  994. rio_spin_unlock_irqrestore(&PortP->portSem, flags);
  995. }
  996. if ( HostMapP->SysPort < p->RIOFirstPortsMapped )
  997. p->RIOFirstPortsMapped = HostMapP->SysPort;
  998. if ( HostMapP->SysPort > p->RIOLastPortsMapped )
  999. p->RIOLastPortsMapped = HostMapP->SysPort;
  1001. return 0;
  1002. }
  1004. int
  1005. RIOChangeName(p, MapP)
  1006. struct rio_info *p;
  1007. struct Map* MapP; 
  1008. {
  1009. int host;
  1010. struct Map *HostMapP;
  1011. char *sptr;
  1013. rio_dprintk (RIO_DEBUG_TABLE, "Change name entry on host %x, rta %x, ID %d, Sysport %dn",
  1014. MapP->HostUniqueNum,MapP->RtaUniqueNum,
  1015. MapP->ID, (int)MapP->SysPort);
  1017. if ( MapP->ID > MAX_RUP ) {
  1018. rio_dprintk (RIO_DEBUG_TABLE, "Bad ID in map entry!n");
  1019. p->RIOError.Error = ID_NUMBER_OUT_OF_RANGE;
  1020. return EINVAL;
  1021. }
  1023. MapP->Name[MAX_NAME_LEN-1] = '';
  1024. sptr = MapP->Name;
  1026. while ( *sptr ) {
  1027. if ( *sptr<' ' || *sptr>'~' ) {
  1028. rio_dprintk (RIO_DEBUG_TABLE, "Name entry contains non-printing characters!n");
  1029. p->RIOError.Error = BAD_CHARACTER_IN_NAME;
  1030. return EINVAL;
  1031. }
  1032. sptr++;
  1033. }
  1035. for ( host=0; host < p->RIONumHosts; host++ ) {
  1036. if ( MapP->HostUniqueNum == p->RIOHosts[host].UniqueNum ) {
  1037. if ( (p->RIOHosts[host].Flags & RUN_STATE) != RC_RUNNING ) {
  1038. p->RIOError.Error = HOST_NOT_RUNNING;
  1039. return ENXIO;
  1040. }
  1041. if ( MapP->ID==0 ) {
  1042. CCOPY( MapP->Name, p->RIOHosts[host].Name, MAX_NAME_LEN );
  1043. return 0;
  1044. }
  1046. HostMapP = &p->RIOHosts[host].Mapping[MapP->ID-1];
  1048. if ( HostMapP->RtaUniqueNum != MapP->RtaUniqueNum ) {
  1049. p->RIOError.Error = RTA_NUMBER_WRONG;
  1050. return ENXIO;
  1051. }
  1052. CCOPY( MapP->Name, HostMapP->Name, MAX_NAME_LEN );
  1053. return 0;
  1054. }
  1055. }
  1056. p->RIOError.Error = UNKNOWN_HOST_NUMBER;
  1057. rio_dprintk (RIO_DEBUG_TABLE, "Unknown host %xn", MapP->HostUniqueNum);
  1058. return ENXIO;
  1059. }