irttp.c 51 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907
  1. /*********************************************************************
  2. *
  3. * Filename: irttp.c
  4. * Version: 1.2
  5. * Description: Tiny Transport Protocol (TTP) implementation
  6. * Status: Stable
  7. * Author: Dag Brattli <dagb@cs.uit.no>
  8. * Created at: Sun Aug 31 20:14:31 1997
  9. * Modified at: Wed Jan 5 11:31:27 2000
  10. * Modified by: Dag Brattli <dagb@cs.uit.no>
  11. *
  12. * Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>,
  13. * All Rights Reserved.
  14. * Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
  15. *
  16. * This program is free software; you can redistribute it and/or
  17. * modify it under the terms of the GNU General Public License as
  18. * published by the Free Software Foundation; either version 2 of
  19. * the License, or (at your option) any later version.
  20. *
  21. * Neither Dag Brattli nor University of Tromsø admit liability nor
  22. * provide warranty for any of this software. This material is
  23. * provided "AS-IS" and at no charge.
  24. *
  25. ********************************************************************/
  26. #include <linux/skbuff.h>
  27. #include <linux/init.h>
  28. #include <linux/fs.h>
  29. #include <linux/seq_file.h>
  30. #include <asm/byteorder.h>
  31. #include <asm/unaligned.h>
  32. #include <net/irda/irda.h>
  33. #include <net/irda/irlap.h>
  34. #include <net/irda/irlmp.h>
  35. #include <net/irda/parameters.h>
  36. #include <net/irda/irttp.h>
  37. static struct irttp_cb *irttp;
  38. static void __irttp_close_tsap(struct tsap_cb *self);
  39. static int irttp_data_indication(void *instance, void *sap,
  40. struct sk_buff *skb);
  41. static int irttp_udata_indication(void *instance, void *sap,
  42. struct sk_buff *skb);
  43. static void irttp_disconnect_indication(void *instance, void *sap,
  44. LM_REASON reason, struct sk_buff *);
  45. static void irttp_connect_indication(void *instance, void *sap,
  46. struct qos_info *qos, __u32 max_sdu_size,
  47. __u8 header_size, struct sk_buff *skb);
  48. static void irttp_connect_confirm(void *instance, void *sap,
  49. struct qos_info *qos, __u32 max_sdu_size,
  50. __u8 header_size, struct sk_buff *skb);
  51. static void irttp_run_tx_queue(struct tsap_cb *self);
  52. static void irttp_run_rx_queue(struct tsap_cb *self);
  53. static void irttp_flush_queues(struct tsap_cb *self);
  54. static void irttp_fragment_skb(struct tsap_cb *self, struct sk_buff *skb);
  55. static struct sk_buff *irttp_reassemble_skb(struct tsap_cb *self);
  56. static void irttp_todo_expired(unsigned long data);
  57. static int irttp_param_max_sdu_size(void *instance, irda_param_t *param,
  58. int get);
  59. static void irttp_flow_indication(void *instance, void *sap, LOCAL_FLOW flow);
  60. static void irttp_status_indication(void *instance,
  61. LINK_STATUS link, LOCK_STATUS lock);
  62. /* Information for parsing parameters in IrTTP */
  63. static pi_minor_info_t pi_minor_call_table[] = {
  64. { NULL, 0 }, /* 0x00 */
  65. { irttp_param_max_sdu_size, PV_INTEGER | PV_BIG_ENDIAN } /* 0x01 */
  66. };
  67. static pi_major_info_t pi_major_call_table[] = {{ pi_minor_call_table, 2 }};
  68. static pi_param_info_t param_info = { pi_major_call_table, 1, 0x0f, 4 };
  69. /************************ GLOBAL PROCEDURES ************************/
  70. /*
  71. * Function irttp_init (void)
  72. *
  73. * Initialize the IrTTP layer. Called by module initialization code
  74. *
  75. */
  76. int __init irttp_init(void)
  77. {
  78. irttp = kzalloc(sizeof(struct irttp_cb), GFP_KERNEL);
  79. if (irttp == NULL)
  80. return -ENOMEM;
  81. irttp->magic = TTP_MAGIC;
  82. irttp->tsaps = hashbin_new(HB_LOCK);
  83. if (!irttp->tsaps) {
  84. IRDA_ERROR("%s: can't allocate IrTTP hashbin!\n",
  85. __FUNCTION__);
  86. kfree(irttp);
  87. return -ENOMEM;
  88. }
  89. return 0;
  90. }
  91. /*
  92. * Function irttp_cleanup (void)
  93. *
  94. * Called by module destruction/cleanup code
  95. *
  96. */
  97. void __exit irttp_cleanup(void)
  98. {
  99. /* Check for main structure */
  100. IRDA_ASSERT(irttp->magic == TTP_MAGIC, return;);
  101. /*
  102. * Delete hashbin and close all TSAP instances in it
  103. */
  104. hashbin_delete(irttp->tsaps, (FREE_FUNC) __irttp_close_tsap);
  105. irttp->magic = 0;
  106. /* De-allocate main structure */
  107. kfree(irttp);
  108. irttp = NULL;
  109. }
  110. /*************************** SUBROUTINES ***************************/
  111. /*
  112. * Function irttp_start_todo_timer (self, timeout)
  113. *
  114. * Start todo timer.
  115. *
  116. * Made it more effient and unsensitive to race conditions - Jean II
  117. */
  118. static inline void irttp_start_todo_timer(struct tsap_cb *self, int timeout)
  119. {
  120. /* Set new value for timer */
  121. mod_timer(&self->todo_timer, jiffies + timeout);
  122. }
  123. /*
  124. * Function irttp_todo_expired (data)
  125. *
  126. * Todo timer has expired!
  127. *
  128. * One of the restriction of the timer is that it is run only on the timer
  129. * interrupt which run every 10ms. This mean that even if you set the timer
  130. * with a delay of 0, it may take up to 10ms before it's run.
  131. * So, to minimise latency and keep cache fresh, we try to avoid using
  132. * it as much as possible.
  133. * Note : we can't use tasklets, because they can't be asynchronously
  134. * killed (need user context), and we can't guarantee that here...
  135. * Jean II
  136. */
  137. static void irttp_todo_expired(unsigned long data)
  138. {
  139. struct tsap_cb *self = (struct tsap_cb *) data;
  140. /* Check that we still exist */
  141. if (!self || self->magic != TTP_TSAP_MAGIC)
  142. return;
  143. IRDA_DEBUG(4, "%s(instance=%p)\n", __FUNCTION__, self);
  144. /* Try to make some progress, especially on Tx side - Jean II */
  145. irttp_run_rx_queue(self);
  146. irttp_run_tx_queue(self);
  147. /* Check if time for disconnect */
  148. if (test_bit(0, &self->disconnect_pend)) {
  149. /* Check if it's possible to disconnect yet */
  150. if (skb_queue_empty(&self->tx_queue)) {
  151. /* Make sure disconnect is not pending anymore */
  152. clear_bit(0, &self->disconnect_pend); /* FALSE */
  153. /* Note : self->disconnect_skb may be NULL */
  154. irttp_disconnect_request(self, self->disconnect_skb,
  155. P_NORMAL);
  156. self->disconnect_skb = NULL;
  157. } else {
  158. /* Try again later */
  159. irttp_start_todo_timer(self, HZ/10);
  160. /* No reason to try and close now */
  161. return;
  162. }
  163. }
  164. /* Check if it's closing time */
  165. if (self->close_pend)
  166. /* Finish cleanup */
  167. irttp_close_tsap(self);
  168. }
  169. /*
  170. * Function irttp_flush_queues (self)
  171. *
  172. * Flushes (removes all frames) in transitt-buffer (tx_list)
  173. */
  174. void irttp_flush_queues(struct tsap_cb *self)
  175. {
  176. struct sk_buff* skb;
  177. IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
  178. IRDA_ASSERT(self != NULL, return;);
  179. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
  180. /* Deallocate frames waiting to be sent */
  181. while ((skb = skb_dequeue(&self->tx_queue)) != NULL)
  182. dev_kfree_skb(skb);
  183. /* Deallocate received frames */
  184. while ((skb = skb_dequeue(&self->rx_queue)) != NULL)
  185. dev_kfree_skb(skb);
  186. /* Deallocate received fragments */
  187. while ((skb = skb_dequeue(&self->rx_fragments)) != NULL)
  188. dev_kfree_skb(skb);
  189. }
  190. /*
  191. * Function irttp_reassemble (self)
  192. *
  193. * Makes a new (continuous) skb of all the fragments in the fragment
  194. * queue
  195. *
  196. */
  197. static struct sk_buff *irttp_reassemble_skb(struct tsap_cb *self)
  198. {
  199. struct sk_buff *skb, *frag;
  200. int n = 0; /* Fragment index */
  201. IRDA_ASSERT(self != NULL, return NULL;);
  202. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return NULL;);
  203. IRDA_DEBUG(2, "%s(), self->rx_sdu_size=%d\n", __FUNCTION__,
  204. self->rx_sdu_size);
  205. skb = dev_alloc_skb(TTP_HEADER + self->rx_sdu_size);
  206. if (!skb)
  207. return NULL;
  208. /*
  209. * Need to reserve space for TTP header in case this skb needs to
  210. * be requeued in case delivery failes
  211. */
  212. skb_reserve(skb, TTP_HEADER);
  213. skb_put(skb, self->rx_sdu_size);
  214. /*
  215. * Copy all fragments to a new buffer
  216. */
  217. while ((frag = skb_dequeue(&self->rx_fragments)) != NULL) {
  218. memcpy(skb->data+n, frag->data, frag->len);
  219. n += frag->len;
  220. dev_kfree_skb(frag);
  221. }
  222. IRDA_DEBUG(2,
  223. "%s(), frame len=%d, rx_sdu_size=%d, rx_max_sdu_size=%d\n",
  224. __FUNCTION__, n, self->rx_sdu_size, self->rx_max_sdu_size);
  225. /* Note : irttp_run_rx_queue() calculate self->rx_sdu_size
  226. * by summing the size of all fragments, so we should always
  227. * have n == self->rx_sdu_size, except in cases where we
  228. * droped the last fragment (when self->rx_sdu_size exceed
  229. * self->rx_max_sdu_size), where n < self->rx_sdu_size.
  230. * Jean II */
  231. IRDA_ASSERT(n <= self->rx_sdu_size, n = self->rx_sdu_size;);
  232. /* Set the new length */
  233. skb_trim(skb, n);
  234. self->rx_sdu_size = 0;
  235. return skb;
  236. }
  237. /*
  238. * Function irttp_fragment_skb (skb)
  239. *
  240. * Fragments a frame and queues all the fragments for transmission
  241. *
  242. */
  243. static inline void irttp_fragment_skb(struct tsap_cb *self,
  244. struct sk_buff *skb)
  245. {
  246. struct sk_buff *frag;
  247. __u8 *frame;
  248. IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
  249. IRDA_ASSERT(self != NULL, return;);
  250. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
  251. IRDA_ASSERT(skb != NULL, return;);
  252. /*
  253. * Split frame into a number of segments
  254. */
  255. while (skb->len > self->max_seg_size) {
  256. IRDA_DEBUG(2, "%s(), fragmenting ...\n", __FUNCTION__);
  257. /* Make new segment */
  258. frag = alloc_skb(self->max_seg_size+self->max_header_size,
  259. GFP_ATOMIC);
  260. if (!frag)
  261. return;
  262. skb_reserve(frag, self->max_header_size);
  263. /* Copy data from the original skb into this fragment. */
  264. memcpy(skb_put(frag, self->max_seg_size), skb->data,
  265. self->max_seg_size);
  266. /* Insert TTP header, with the more bit set */
  267. frame = skb_push(frag, TTP_HEADER);
  268. frame[0] = TTP_MORE;
  269. /* Hide the copied data from the original skb */
  270. skb_pull(skb, self->max_seg_size);
  271. /* Queue fragment */
  272. skb_queue_tail(&self->tx_queue, frag);
  273. }
  274. /* Queue what is left of the original skb */
  275. IRDA_DEBUG(2, "%s(), queuing last segment\n", __FUNCTION__);
  276. frame = skb_push(skb, TTP_HEADER);
  277. frame[0] = 0x00; /* Clear more bit */
  278. /* Queue fragment */
  279. skb_queue_tail(&self->tx_queue, skb);
  280. }
  281. /*
  282. * Function irttp_param_max_sdu_size (self, param)
  283. *
  284. * Handle the MaxSduSize parameter in the connect frames, this function
  285. * will be called both when this parameter needs to be inserted into, and
  286. * extracted from the connect frames
  287. */
  288. static int irttp_param_max_sdu_size(void *instance, irda_param_t *param,
  289. int get)
  290. {
  291. struct tsap_cb *self;
  292. self = (struct tsap_cb *) instance;
  293. IRDA_ASSERT(self != NULL, return -1;);
  294. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
  295. if (get)
  296. param->pv.i = self->tx_max_sdu_size;
  297. else
  298. self->tx_max_sdu_size = param->pv.i;
  299. IRDA_DEBUG(1, "%s(), MaxSduSize=%d\n", __FUNCTION__, param->pv.i);
  300. return 0;
  301. }
  302. /*************************** CLIENT CALLS ***************************/
  303. /************************** LMP CALLBACKS **************************/
  304. /* Everything is happily mixed up. Waiting for next clean up - Jean II */
  305. /*
  306. * Function irttp_open_tsap (stsap, notify)
  307. *
  308. * Create TSAP connection endpoint,
  309. */
  310. struct tsap_cb *irttp_open_tsap(__u8 stsap_sel, int credit, notify_t *notify)
  311. {
  312. struct tsap_cb *self;
  313. struct lsap_cb *lsap;
  314. notify_t ttp_notify;
  315. IRDA_ASSERT(irttp->magic == TTP_MAGIC, return NULL;);
  316. /* The IrLMP spec (IrLMP 1.1 p10) says that we have the right to
  317. * use only 0x01-0x6F. Of course, we can use LSAP_ANY as well.
  318. * JeanII */
  319. if((stsap_sel != LSAP_ANY) &&
  320. ((stsap_sel < 0x01) || (stsap_sel >= 0x70))) {
  321. IRDA_DEBUG(0, "%s(), invalid tsap!\n", __FUNCTION__);
  322. return NULL;
  323. }
  324. self = kzalloc(sizeof(struct tsap_cb), GFP_ATOMIC);
  325. if (self == NULL) {
  326. IRDA_DEBUG(0, "%s(), unable to kmalloc!\n", __FUNCTION__);
  327. return NULL;
  328. }
  329. spin_lock_init(&self->lock);
  330. /* Initialise todo timer */
  331. init_timer(&self->todo_timer);
  332. self->todo_timer.data = (unsigned long) self;
  333. self->todo_timer.function = &irttp_todo_expired;
  334. /* Initialize callbacks for IrLMP to use */
  335. irda_notify_init(&ttp_notify);
  336. ttp_notify.connect_confirm = irttp_connect_confirm;
  337. ttp_notify.connect_indication = irttp_connect_indication;
  338. ttp_notify.disconnect_indication = irttp_disconnect_indication;
  339. ttp_notify.data_indication = irttp_data_indication;
  340. ttp_notify.udata_indication = irttp_udata_indication;
  341. ttp_notify.flow_indication = irttp_flow_indication;
  342. if(notify->status_indication != NULL)
  343. ttp_notify.status_indication = irttp_status_indication;
  344. ttp_notify.instance = self;
  345. strncpy(ttp_notify.name, notify->name, NOTIFY_MAX_NAME);
  346. self->magic = TTP_TSAP_MAGIC;
  347. self->connected = FALSE;
  348. skb_queue_head_init(&self->rx_queue);
  349. skb_queue_head_init(&self->tx_queue);
  350. skb_queue_head_init(&self->rx_fragments);
  351. /*
  352. * Create LSAP at IrLMP layer
  353. */
  354. lsap = irlmp_open_lsap(stsap_sel, &ttp_notify, 0);
  355. if (lsap == NULL) {
  356. IRDA_WARNING("%s: unable to allocate LSAP!!\n", __FUNCTION__);
  357. return NULL;
  358. }
  359. /*
  360. * If user specified LSAP_ANY as source TSAP selector, then IrLMP
  361. * will replace it with whatever source selector which is free, so
  362. * the stsap_sel we have might not be valid anymore
  363. */
  364. self->stsap_sel = lsap->slsap_sel;
  365. IRDA_DEBUG(4, "%s(), stsap_sel=%02x\n", __FUNCTION__, self->stsap_sel);
  366. self->notify = *notify;
  367. self->lsap = lsap;
  368. hashbin_insert(irttp->tsaps, (irda_queue_t *) self, (long) self, NULL);
  369. if (credit > TTP_RX_MAX_CREDIT)
  370. self->initial_credit = TTP_RX_MAX_CREDIT;
  371. else
  372. self->initial_credit = credit;
  373. return self;
  374. }
  375. EXPORT_SYMBOL(irttp_open_tsap);
  376. /*
  377. * Function irttp_close (handle)
  378. *
  379. * Remove an instance of a TSAP. This function should only deal with the
  380. * deallocation of the TSAP, and resetting of the TSAPs values;
  381. *
  382. */
  383. static void __irttp_close_tsap(struct tsap_cb *self)
  384. {
  385. /* First make sure we're connected. */
  386. IRDA_ASSERT(self != NULL, return;);
  387. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
  388. irttp_flush_queues(self);
  389. del_timer(&self->todo_timer);
  390. /* This one won't be cleaned up if we are disconnect_pend + close_pend
  391. * and we receive a disconnect_indication */
  392. if (self->disconnect_skb)
  393. dev_kfree_skb(self->disconnect_skb);
  394. self->connected = FALSE;
  395. self->magic = ~TTP_TSAP_MAGIC;
  396. kfree(self);
  397. }
  398. /*
  399. * Function irttp_close (self)
  400. *
  401. * Remove TSAP from list of all TSAPs and then deallocate all resources
  402. * associated with this TSAP
  403. *
  404. * Note : because we *free* the tsap structure, it is the responsibility
  405. * of the caller to make sure we are called only once and to deal with
  406. * possible race conditions. - Jean II
  407. */
  408. int irttp_close_tsap(struct tsap_cb *self)
  409. {
  410. struct tsap_cb *tsap;
  411. IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
  412. IRDA_ASSERT(self != NULL, return -1;);
  413. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
  414. /* Make sure tsap has been disconnected */
  415. if (self->connected) {
  416. /* Check if disconnect is not pending */
  417. if (!test_bit(0, &self->disconnect_pend)) {
  418. IRDA_WARNING("%s: TSAP still connected!\n",
  419. __FUNCTION__);
  420. irttp_disconnect_request(self, NULL, P_NORMAL);
  421. }
  422. self->close_pend = TRUE;
  423. irttp_start_todo_timer(self, HZ/10);
  424. return 0; /* Will be back! */
  425. }
  426. tsap = hashbin_remove(irttp->tsaps, (long) self, NULL);
  427. IRDA_ASSERT(tsap == self, return -1;);
  428. /* Close corresponding LSAP */
  429. if (self->lsap) {
  430. irlmp_close_lsap(self->lsap);
  431. self->lsap = NULL;
  432. }
  433. __irttp_close_tsap(self);
  434. return 0;
  435. }
  436. EXPORT_SYMBOL(irttp_close_tsap);
  437. /*
  438. * Function irttp_udata_request (self, skb)
  439. *
  440. * Send unreliable data on this TSAP
  441. *
  442. */
  443. int irttp_udata_request(struct tsap_cb *self, struct sk_buff *skb)
  444. {
  445. IRDA_ASSERT(self != NULL, return -1;);
  446. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
  447. IRDA_ASSERT(skb != NULL, return -1;);
  448. IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
  449. /* Check that nothing bad happens */
  450. if ((skb->len == 0) || (!self->connected)) {
  451. IRDA_DEBUG(1, "%s(), No data, or not connected\n",
  452. __FUNCTION__);
  453. goto err;
  454. }
  455. if (skb->len > self->max_seg_size) {
  456. IRDA_DEBUG(1, "%s(), UData is to large for IrLAP!\n",
  457. __FUNCTION__);
  458. goto err;
  459. }
  460. irlmp_udata_request(self->lsap, skb);
  461. self->stats.tx_packets++;
  462. return 0;
  463. err:
  464. dev_kfree_skb(skb);
  465. return -1;
  466. }
  467. EXPORT_SYMBOL(irttp_udata_request);
  468. /*
  469. * Function irttp_data_request (handle, skb)
  470. *
  471. * Queue frame for transmission. If SAR is enabled, fragement the frame
  472. * and queue the fragments for transmission
  473. */
  474. int irttp_data_request(struct tsap_cb *self, struct sk_buff *skb)
  475. {
  476. __u8 *frame;
  477. int ret;
  478. IRDA_ASSERT(self != NULL, return -1;);
  479. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
  480. IRDA_ASSERT(skb != NULL, return -1;);
  481. IRDA_DEBUG(2, "%s() : queue len = %d\n", __FUNCTION__,
  482. skb_queue_len(&self->tx_queue));
  483. /* Check that nothing bad happens */
  484. if ((skb->len == 0) || (!self->connected)) {
  485. IRDA_WARNING("%s: No data, or not connected\n", __FUNCTION__);
  486. ret = -ENOTCONN;
  487. goto err;
  488. }
  489. /*
  490. * Check if SAR is disabled, and the frame is larger than what fits
  491. * inside an IrLAP frame
  492. */
  493. if ((self->tx_max_sdu_size == 0) && (skb->len > self->max_seg_size)) {
  494. IRDA_ERROR("%s: SAR disabled, and data is to large for IrLAP!\n",
  495. __FUNCTION__);
  496. ret = -EMSGSIZE;
  497. goto err;
  498. }
  499. /*
  500. * Check if SAR is enabled, and the frame is larger than the
  501. * TxMaxSduSize
  502. */
  503. if ((self->tx_max_sdu_size != 0) &&
  504. (self->tx_max_sdu_size != TTP_SAR_UNBOUND) &&
  505. (skb->len > self->tx_max_sdu_size))
  506. {
  507. IRDA_ERROR("%s: SAR enabled, but data is larger than TxMaxSduSize!\n",
  508. __FUNCTION__);
  509. ret = -EMSGSIZE;
  510. goto err;
  511. }
  512. /*
  513. * Check if transmit queue is full
  514. */
  515. if (skb_queue_len(&self->tx_queue) >= TTP_TX_MAX_QUEUE) {
  516. /*
  517. * Give it a chance to empty itself
  518. */
  519. irttp_run_tx_queue(self);
  520. /* Drop packet. This error code should trigger the caller
  521. * to resend the data in the client code - Jean II */
  522. ret = -ENOBUFS;
  523. goto err;
  524. }
  525. /* Queue frame, or queue frame segments */
  526. if ((self->tx_max_sdu_size == 0) || (skb->len < self->max_seg_size)) {
  527. /* Queue frame */
  528. IRDA_ASSERT(skb_headroom(skb) >= TTP_HEADER, return -1;);
  529. frame = skb_push(skb, TTP_HEADER);
  530. frame[0] = 0x00; /* Clear more bit */
  531. skb_queue_tail(&self->tx_queue, skb);
  532. } else {
  533. /*
  534. * Fragment the frame, this function will also queue the
  535. * fragments, we don't care about the fact the transmit
  536. * queue may be overfilled by all the segments for a little
  537. * while
  538. */
  539. irttp_fragment_skb(self, skb);
  540. }
  541. /* Check if we can accept more data from client */
  542. if ((!self->tx_sdu_busy) &&
  543. (skb_queue_len(&self->tx_queue) > TTP_TX_HIGH_THRESHOLD)) {
  544. /* Tx queue filling up, so stop client. */
  545. if (self->notify.flow_indication) {
  546. self->notify.flow_indication(self->notify.instance,
  547. self, FLOW_STOP);
  548. }
  549. /* self->tx_sdu_busy is the state of the client.
  550. * Update state after notifying client to avoid
  551. * race condition with irttp_flow_indication().
  552. * If the queue empty itself after our test but before
  553. * we set the flag, we will fix ourselves below in
  554. * irttp_run_tx_queue().
  555. * Jean II */
  556. self->tx_sdu_busy = TRUE;
  557. }
  558. /* Try to make some progress */
  559. irttp_run_tx_queue(self);
  560. return 0;
  561. err:
  562. dev_kfree_skb(skb);
  563. return ret;
  564. }
  565. EXPORT_SYMBOL(irttp_data_request);
  566. /*
  567. * Function irttp_run_tx_queue (self)
  568. *
  569. * Transmit packets queued for transmission (if possible)
  570. *
  571. */
  572. static void irttp_run_tx_queue(struct tsap_cb *self)
  573. {
  574. struct sk_buff *skb;
  575. unsigned long flags;
  576. int n;
  577. IRDA_DEBUG(2, "%s() : send_credit = %d, queue_len = %d\n",
  578. __FUNCTION__,
  579. self->send_credit, skb_queue_len(&self->tx_queue));
  580. /* Get exclusive access to the tx queue, otherwise don't touch it */
  581. if (irda_lock(&self->tx_queue_lock) == FALSE)
  582. return;
  583. /* Try to send out frames as long as we have credits
  584. * and as long as LAP is not full. If LAP is full, it will
  585. * poll us through irttp_flow_indication() - Jean II */
  586. while ((self->send_credit > 0) &&
  587. (!irlmp_lap_tx_queue_full(self->lsap)) &&
  588. (skb = skb_dequeue(&self->tx_queue)))
  589. {
  590. /*
  591. * Since we can transmit and receive frames concurrently,
  592. * the code below is a critical region and we must assure that
  593. * nobody messes with the credits while we update them.
  594. */
  595. spin_lock_irqsave(&self->lock, flags);
  596. n = self->avail_credit;
  597. self->avail_credit = 0;
  598. /* Only room for 127 credits in frame */
  599. if (n > 127) {
  600. self->avail_credit = n-127;
  601. n = 127;
  602. }
  603. self->remote_credit += n;
  604. self->send_credit--;
  605. spin_unlock_irqrestore(&self->lock, flags);
  606. /*
  607. * More bit must be set by the data_request() or fragment()
  608. * functions
  609. */
  610. skb->data[0] |= (n & 0x7f);
  611. /* Detach from socket.
  612. * The current skb has a reference to the socket that sent
  613. * it (skb->sk). When we pass it to IrLMP, the skb will be
  614. * stored in in IrLAP (self->wx_list). When we are within
  615. * IrLAP, we lose the notion of socket, so we should not
  616. * have a reference to a socket. So, we drop it here.
  617. *
  618. * Why does it matter ?
  619. * When the skb is freed (kfree_skb), if it is associated
  620. * with a socket, it release buffer space on the socket
  621. * (through sock_wfree() and sock_def_write_space()).
  622. * If the socket no longer exist, we may crash. Hard.
  623. * When we close a socket, we make sure that associated packets
  624. * in IrTTP are freed. However, we have no way to cancel
  625. * the packet that we have passed to IrLAP. So, if a packet
  626. * remains in IrLAP (retry on the link or else) after we
  627. * close the socket, we are dead !
  628. * Jean II */
  629. if (skb->sk != NULL) {
  630. /* IrSOCK application, IrOBEX, ... */
  631. skb_orphan(skb);
  632. }
  633. /* IrCOMM over IrTTP, IrLAN, ... */
  634. /* Pass the skb to IrLMP - done */
  635. irlmp_data_request(self->lsap, skb);
  636. self->stats.tx_packets++;
  637. }
  638. /* Check if we can accept more frames from client.
  639. * We don't want to wait until the todo timer to do that, and we
  640. * can't use tasklets (grr...), so we are obliged to give control
  641. * to client. That's ok, this test will be true not too often
  642. * (max once per LAP window) and we are called from places
  643. * where we can spend a bit of time doing stuff. - Jean II */
  644. if ((self->tx_sdu_busy) &&
  645. (skb_queue_len(&self->tx_queue) < TTP_TX_LOW_THRESHOLD) &&
  646. (!self->close_pend))
  647. {
  648. if (self->notify.flow_indication)
  649. self->notify.flow_indication(self->notify.instance,
  650. self, FLOW_START);
  651. /* self->tx_sdu_busy is the state of the client.
  652. * We don't really have a race here, but it's always safer
  653. * to update our state after the client - Jean II */
  654. self->tx_sdu_busy = FALSE;
  655. }
  656. /* Reset lock */
  657. self->tx_queue_lock = 0;
  658. }
  659. /*
  660. * Function irttp_give_credit (self)
  661. *
  662. * Send a dataless flowdata TTP-PDU and give available credit to peer
  663. * TSAP
  664. */
  665. static inline void irttp_give_credit(struct tsap_cb *self)
  666. {
  667. struct sk_buff *tx_skb = NULL;
  668. unsigned long flags;
  669. int n;
  670. IRDA_ASSERT(self != NULL, return;);
  671. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
  672. IRDA_DEBUG(4, "%s() send=%d,avail=%d,remote=%d\n",
  673. __FUNCTION__,
  674. self->send_credit, self->avail_credit, self->remote_credit);
  675. /* Give credit to peer */
  676. tx_skb = alloc_skb(TTP_MAX_HEADER, GFP_ATOMIC);
  677. if (!tx_skb)
  678. return;
  679. /* Reserve space for LMP, and LAP header */
  680. skb_reserve(tx_skb, LMP_MAX_HEADER);
  681. /*
  682. * Since we can transmit and receive frames concurrently,
  683. * the code below is a critical region and we must assure that
  684. * nobody messes with the credits while we update them.
  685. */
  686. spin_lock_irqsave(&self->lock, flags);
  687. n = self->avail_credit;
  688. self->avail_credit = 0;
  689. /* Only space for 127 credits in frame */
  690. if (n > 127) {
  691. self->avail_credit = n - 127;
  692. n = 127;
  693. }
  694. self->remote_credit += n;
  695. spin_unlock_irqrestore(&self->lock, flags);
  696. skb_put(tx_skb, 1);
  697. tx_skb->data[0] = (__u8) (n & 0x7f);
  698. irlmp_data_request(self->lsap, tx_skb);
  699. self->stats.tx_packets++;
  700. }
  701. /*
  702. * Function irttp_udata_indication (instance, sap, skb)
  703. *
  704. * Received some unit-data (unreliable)
  705. *
  706. */
  707. static int irttp_udata_indication(void *instance, void *sap,
  708. struct sk_buff *skb)
  709. {
  710. struct tsap_cb *self;
  711. int err;
  712. IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
  713. self = (struct tsap_cb *) instance;
  714. IRDA_ASSERT(self != NULL, return -1;);
  715. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
  716. IRDA_ASSERT(skb != NULL, return -1;);
  717. self->stats.rx_packets++;
  718. /* Just pass data to layer above */
  719. if (self->notify.udata_indication) {
  720. err = self->notify.udata_indication(self->notify.instance,
  721. self,skb);
  722. /* Same comment as in irttp_do_data_indication() */
  723. if (!err)
  724. return 0;
  725. }
  726. /* Either no handler, or handler returns an error */
  727. dev_kfree_skb(skb);
  728. return 0;
  729. }
  730. /*
  731. * Function irttp_data_indication (instance, sap, skb)
  732. *
  733. * Receive segment from IrLMP.
  734. *
  735. */
  736. static int irttp_data_indication(void *instance, void *sap,
  737. struct sk_buff *skb)
  738. {
  739. struct tsap_cb *self;
  740. unsigned long flags;
  741. int n;
  742. self = (struct tsap_cb *) instance;
  743. n = skb->data[0] & 0x7f; /* Extract the credits */
  744. self->stats.rx_packets++;
  745. /* Deal with inbound credit
  746. * Since we can transmit and receive frames concurrently,
  747. * the code below is a critical region and we must assure that
  748. * nobody messes with the credits while we update them.
  749. */
  750. spin_lock_irqsave(&self->lock, flags);
  751. self->send_credit += n;
  752. if (skb->len > 1)
  753. self->remote_credit--;
  754. spin_unlock_irqrestore(&self->lock, flags);
  755. /*
  756. * Data or dataless packet? Dataless frames contains only the
  757. * TTP_HEADER.
  758. */
  759. if (skb->len > 1) {
  760. /*
  761. * We don't remove the TTP header, since we must preserve the
  762. * more bit, so the defragment routing knows what to do
  763. */
  764. skb_queue_tail(&self->rx_queue, skb);
  765. } else {
  766. /* Dataless flowdata TTP-PDU */
  767. dev_kfree_skb(skb);
  768. }
  769. /* Push data to the higher layer.
  770. * We do it synchronously because running the todo timer for each
  771. * receive packet would be too much overhead and latency.
  772. * By passing control to the higher layer, we run the risk that
  773. * it may take time or grab a lock. Most often, the higher layer
  774. * will only put packet in a queue.
  775. * Anyway, packets are only dripping through the IrDA, so we can
  776. * have time before the next packet.
  777. * Further, we are run from NET_BH, so the worse that can happen is
  778. * us missing the optimal time to send back the PF bit in LAP.
  779. * Jean II */
  780. irttp_run_rx_queue(self);
  781. /* We now give credits to peer in irttp_run_rx_queue().
  782. * We need to send credit *NOW*, otherwise we are going
  783. * to miss the next Tx window. The todo timer may take
  784. * a while before it's run... - Jean II */
  785. /*
  786. * If the peer device has given us some credits and we didn't have
  787. * anyone from before, then we need to shedule the tx queue.
  788. * We need to do that because our Tx have stopped (so we may not
  789. * get any LAP flow indication) and the user may be stopped as
  790. * well. - Jean II
  791. */
  792. if (self->send_credit == n) {
  793. /* Restart pushing stuff to LAP */
  794. irttp_run_tx_queue(self);
  795. /* Note : we don't want to schedule the todo timer
  796. * because it has horrible latency. No tasklets
  797. * because the tasklet API is broken. - Jean II */
  798. }
  799. return 0;
  800. }
  801. /*
  802. * Function irttp_status_indication (self, reason)
  803. *
  804. * Status_indication, just pass to the higher layer...
  805. *
  806. */
  807. static void irttp_status_indication(void *instance,
  808. LINK_STATUS link, LOCK_STATUS lock)
  809. {
  810. struct tsap_cb *self;
  811. IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
  812. self = (struct tsap_cb *) instance;
  813. IRDA_ASSERT(self != NULL, return;);
  814. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
  815. /* Check if client has already closed the TSAP and gone away */
  816. if (self->close_pend)
  817. return;
  818. /*
  819. * Inform service user if he has requested it
  820. */
  821. if (self->notify.status_indication != NULL)
  822. self->notify.status_indication(self->notify.instance,
  823. link, lock);
  824. else
  825. IRDA_DEBUG(2, "%s(), no handler\n", __FUNCTION__);
  826. }
  827. /*
  828. * Function irttp_flow_indication (self, reason)
  829. *
  830. * Flow_indication : IrLAP tells us to send more data.
  831. *
  832. */
  833. static void irttp_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
  834. {
  835. struct tsap_cb *self;
  836. self = (struct tsap_cb *) instance;
  837. IRDA_ASSERT(self != NULL, return;);
  838. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
  839. IRDA_DEBUG(4, "%s(instance=%p)\n", __FUNCTION__, self);
  840. /* We are "polled" directly from LAP, and the LAP want to fill
  841. * its Tx window. We want to do our best to send it data, so that
  842. * we maximise the window. On the other hand, we want to limit the
  843. * amount of work here so that LAP doesn't hang forever waiting
  844. * for packets. - Jean II */
  845. /* Try to send some packets. Currently, LAP calls us every time
  846. * there is one free slot, so we will send only one packet.
  847. * This allow the scheduler to do its round robin - Jean II */
  848. irttp_run_tx_queue(self);
  849. /* Note regarding the interraction with higher layer.
  850. * irttp_run_tx_queue() may call the client when its queue
  851. * start to empty, via notify.flow_indication(). Initially.
  852. * I wanted this to happen in a tasklet, to avoid client
  853. * grabbing the CPU, but we can't use tasklets safely. And timer
  854. * is definitely too slow.
  855. * This will happen only once per LAP window, and usually at
  856. * the third packet (unless window is smaller). LAP is still
  857. * doing mtt and sending first packet so it's sort of OK
  858. * to do that. Jean II */
  859. /* If we need to send disconnect. try to do it now */
  860. if(self->disconnect_pend)
  861. irttp_start_todo_timer(self, 0);
  862. }
  863. /*
  864. * Function irttp_flow_request (self, command)
  865. *
  866. * This function could be used by the upper layers to tell IrTTP to stop
  867. * delivering frames if the receive queues are starting to get full, or
  868. * to tell IrTTP to start delivering frames again.
  869. */
  870. void irttp_flow_request(struct tsap_cb *self, LOCAL_FLOW flow)
  871. {
  872. IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
  873. IRDA_ASSERT(self != NULL, return;);
  874. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
  875. switch (flow) {
  876. case FLOW_STOP:
  877. IRDA_DEBUG(1, "%s(), flow stop\n", __FUNCTION__);
  878. self->rx_sdu_busy = TRUE;
  879. break;
  880. case FLOW_START:
  881. IRDA_DEBUG(1, "%s(), flow start\n", __FUNCTION__);
  882. self->rx_sdu_busy = FALSE;
  883. /* Client say he can accept more data, try to free our
  884. * queues ASAP - Jean II */
  885. irttp_run_rx_queue(self);
  886. break;
  887. default:
  888. IRDA_DEBUG(1, "%s(), Unknown flow command!\n", __FUNCTION__);
  889. }
  890. }
  891. EXPORT_SYMBOL(irttp_flow_request);
  892. /*
  893. * Function irttp_connect_request (self, dtsap_sel, daddr, qos)
  894. *
  895. * Try to connect to remote destination TSAP selector
  896. *
  897. */
  898. int irttp_connect_request(struct tsap_cb *self, __u8 dtsap_sel,
  899. __u32 saddr, __u32 daddr,
  900. struct qos_info *qos, __u32 max_sdu_size,
  901. struct sk_buff *userdata)
  902. {
  903. struct sk_buff *tx_skb;
  904. __u8 *frame;
  905. __u8 n;
  906. IRDA_DEBUG(4, "%s(), max_sdu_size=%d\n", __FUNCTION__, max_sdu_size);
  907. IRDA_ASSERT(self != NULL, return -EBADR;);
  908. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -EBADR;);
  909. if (self->connected) {
  910. if(userdata)
  911. dev_kfree_skb(userdata);
  912. return -EISCONN;
  913. }
  914. /* Any userdata supplied? */
  915. if (userdata == NULL) {
  916. tx_skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER,
  917. GFP_ATOMIC);
  918. if (!tx_skb)
  919. return -ENOMEM;
  920. /* Reserve space for MUX_CONTROL and LAP header */
  921. skb_reserve(tx_skb, TTP_MAX_HEADER + TTP_SAR_HEADER);
  922. } else {
  923. tx_skb = userdata;
  924. /*
  925. * Check that the client has reserved enough space for
  926. * headers
  927. */
  928. IRDA_ASSERT(skb_headroom(userdata) >= TTP_MAX_HEADER,
  929. { dev_kfree_skb(userdata); return -1; } );
  930. }
  931. /* Initialize connection parameters */
  932. self->connected = FALSE;
  933. self->avail_credit = 0;
  934. self->rx_max_sdu_size = max_sdu_size;
  935. self->rx_sdu_size = 0;
  936. self->rx_sdu_busy = FALSE;
  937. self->dtsap_sel = dtsap_sel;
  938. n = self->initial_credit;
  939. self->remote_credit = 0;
  940. self->send_credit = 0;
  941. /*
  942. * Give away max 127 credits for now
  943. */
  944. if (n > 127) {
  945. self->avail_credit=n-127;
  946. n = 127;
  947. }
  948. self->remote_credit = n;
  949. /* SAR enabled? */
  950. if (max_sdu_size > 0) {
  951. IRDA_ASSERT(skb_headroom(tx_skb) >= (TTP_MAX_HEADER + TTP_SAR_HEADER),
  952. { dev_kfree_skb(tx_skb); return -1; } );
  953. /* Insert SAR parameters */
  954. frame = skb_push(tx_skb, TTP_HEADER+TTP_SAR_HEADER);
  955. frame[0] = TTP_PARAMETERS | n;
  956. frame[1] = 0x04; /* Length */
  957. frame[2] = 0x01; /* MaxSduSize */
  958. frame[3] = 0x02; /* Value length */
  959. put_unaligned(cpu_to_be16((__u16) max_sdu_size),
  960. (__be16 *)(frame+4));
  961. } else {
  962. /* Insert plain TTP header */
  963. frame = skb_push(tx_skb, TTP_HEADER);
  964. /* Insert initial credit in frame */
  965. frame[0] = n & 0x7f;
  966. }
  967. /* Connect with IrLMP. No QoS parameters for now */
  968. return irlmp_connect_request(self->lsap, dtsap_sel, saddr, daddr, qos,
  969. tx_skb);
  970. }
  971. EXPORT_SYMBOL(irttp_connect_request);
  972. /*
  973. * Function irttp_connect_confirm (handle, qos, skb)
  974. *
  975. * Sevice user confirms TSAP connection with peer.
  976. *
  977. */
  978. static void irttp_connect_confirm(void *instance, void *sap,
  979. struct qos_info *qos, __u32 max_seg_size,
  980. __u8 max_header_size, struct sk_buff *skb)
  981. {
  982. struct tsap_cb *self;
  983. int parameters;
  984. int ret;
  985. __u8 plen;
  986. __u8 n;
  987. IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
  988. self = (struct tsap_cb *) instance;
  989. IRDA_ASSERT(self != NULL, return;);
  990. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
  991. IRDA_ASSERT(skb != NULL, return;);
  992. self->max_seg_size = max_seg_size - TTP_HEADER;
  993. self->max_header_size = max_header_size + TTP_HEADER;
  994. /*
  995. * Check if we have got some QoS parameters back! This should be the
  996. * negotiated QoS for the link.
  997. */
  998. if (qos) {
  999. IRDA_DEBUG(4, "IrTTP, Negotiated BAUD_RATE: %02x\n",
  1000. qos->baud_rate.bits);
  1001. IRDA_DEBUG(4, "IrTTP, Negotiated BAUD_RATE: %d bps.\n",
  1002. qos->baud_rate.value);
  1003. }
  1004. n = skb->data[0] & 0x7f;
  1005. IRDA_DEBUG(4, "%s(), Initial send_credit=%d\n", __FUNCTION__, n);
  1006. self->send_credit = n;
  1007. self->tx_max_sdu_size = 0;
  1008. self->connected = TRUE;
  1009. parameters = skb->data[0] & 0x80;
  1010. IRDA_ASSERT(skb->len >= TTP_HEADER, return;);
  1011. skb_pull(skb, TTP_HEADER);
  1012. if (parameters) {
  1013. plen = skb->data[0];
  1014. ret = irda_param_extract_all(self, skb->data+1,
  1015. IRDA_MIN(skb->len-1, plen),
  1016. &param_info);
  1017. /* Any errors in the parameter list? */
  1018. if (ret < 0) {
  1019. IRDA_WARNING("%s: error extracting parameters\n",
  1020. __FUNCTION__);
  1021. dev_kfree_skb(skb);
  1022. /* Do not accept this connection attempt */
  1023. return;
  1024. }
  1025. /* Remove parameters */
  1026. skb_pull(skb, IRDA_MIN(skb->len, plen+1));
  1027. }
  1028. IRDA_DEBUG(4, "%s() send=%d,avail=%d,remote=%d\n", __FUNCTION__,
  1029. self->send_credit, self->avail_credit, self->remote_credit);
  1030. IRDA_DEBUG(2, "%s(), MaxSduSize=%d\n", __FUNCTION__,
  1031. self->tx_max_sdu_size);
  1032. if (self->notify.connect_confirm) {
  1033. self->notify.connect_confirm(self->notify.instance, self, qos,
  1034. self->tx_max_sdu_size,
  1035. self->max_header_size, skb);
  1036. } else
  1037. dev_kfree_skb(skb);
  1038. }
  1039. /*
  1040. * Function irttp_connect_indication (handle, skb)
  1041. *
  1042. * Some other device is connecting to this TSAP
  1043. *
  1044. */
  1045. void irttp_connect_indication(void *instance, void *sap, struct qos_info *qos,
  1046. __u32 max_seg_size, __u8 max_header_size,
  1047. struct sk_buff *skb)
  1048. {
  1049. struct tsap_cb *self;
  1050. struct lsap_cb *lsap;
  1051. int parameters;
  1052. int ret;
  1053. __u8 plen;
  1054. __u8 n;
  1055. self = (struct tsap_cb *) instance;
  1056. IRDA_ASSERT(self != NULL, return;);
  1057. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
  1058. IRDA_ASSERT(skb != NULL, return;);
  1059. lsap = (struct lsap_cb *) sap;
  1060. self->max_seg_size = max_seg_size - TTP_HEADER;
  1061. self->max_header_size = max_header_size+TTP_HEADER;
  1062. IRDA_DEBUG(4, "%s(), TSAP sel=%02x\n", __FUNCTION__, self->stsap_sel);
  1063. /* Need to update dtsap_sel if its equal to LSAP_ANY */
  1064. self->dtsap_sel = lsap->dlsap_sel;
  1065. n = skb->data[0] & 0x7f;
  1066. self->send_credit = n;
  1067. self->tx_max_sdu_size = 0;
  1068. parameters = skb->data[0] & 0x80;
  1069. IRDA_ASSERT(skb->len >= TTP_HEADER, return;);
  1070. skb_pull(skb, TTP_HEADER);
  1071. if (parameters) {
  1072. plen = skb->data[0];
  1073. ret = irda_param_extract_all(self, skb->data+1,
  1074. IRDA_MIN(skb->len-1, plen),
  1075. &param_info);
  1076. /* Any errors in the parameter list? */
  1077. if (ret < 0) {
  1078. IRDA_WARNING("%s: error extracting parameters\n",
  1079. __FUNCTION__);
  1080. dev_kfree_skb(skb);
  1081. /* Do not accept this connection attempt */
  1082. return;
  1083. }
  1084. /* Remove parameters */
  1085. skb_pull(skb, IRDA_MIN(skb->len, plen+1));
  1086. }
  1087. if (self->notify.connect_indication) {
  1088. self->notify.connect_indication(self->notify.instance, self,
  1089. qos, self->tx_max_sdu_size,
  1090. self->max_header_size, skb);
  1091. } else
  1092. dev_kfree_skb(skb);
  1093. }
  1094. /*
  1095. * Function irttp_connect_response (handle, userdata)
  1096. *
  1097. * Service user is accepting the connection, just pass it down to
  1098. * IrLMP!
  1099. *
  1100. */
  1101. int irttp_connect_response(struct tsap_cb *self, __u32 max_sdu_size,
  1102. struct sk_buff *userdata)
  1103. {
  1104. struct sk_buff *tx_skb;
  1105. __u8 *frame;
  1106. int ret;
  1107. __u8 n;
  1108. IRDA_ASSERT(self != NULL, return -1;);
  1109. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
  1110. IRDA_DEBUG(4, "%s(), Source TSAP selector=%02x\n", __FUNCTION__,
  1111. self->stsap_sel);
  1112. /* Any userdata supplied? */
  1113. if (userdata == NULL) {
  1114. tx_skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER,
  1115. GFP_ATOMIC);
  1116. if (!tx_skb)
  1117. return -ENOMEM;
  1118. /* Reserve space for MUX_CONTROL and LAP header */
  1119. skb_reserve(tx_skb, TTP_MAX_HEADER + TTP_SAR_HEADER);
  1120. } else {
  1121. tx_skb = userdata;
  1122. /*
  1123. * Check that the client has reserved enough space for
  1124. * headers
  1125. */
  1126. IRDA_ASSERT(skb_headroom(userdata) >= TTP_MAX_HEADER,
  1127. { dev_kfree_skb(userdata); return -1; } );
  1128. }
  1129. self->avail_credit = 0;
  1130. self->remote_credit = 0;
  1131. self->rx_max_sdu_size = max_sdu_size;
  1132. self->rx_sdu_size = 0;
  1133. self->rx_sdu_busy = FALSE;
  1134. n = self->initial_credit;
  1135. /* Frame has only space for max 127 credits (7 bits) */
  1136. if (n > 127) {
  1137. self->avail_credit = n - 127;
  1138. n = 127;
  1139. }
  1140. self->remote_credit = n;
  1141. self->connected = TRUE;
  1142. /* SAR enabled? */
  1143. if (max_sdu_size > 0) {
  1144. IRDA_ASSERT(skb_headroom(tx_skb) >= (TTP_MAX_HEADER + TTP_SAR_HEADER),
  1145. { dev_kfree_skb(tx_skb); return -1; } );
  1146. /* Insert TTP header with SAR parameters */
  1147. frame = skb_push(tx_skb, TTP_HEADER+TTP_SAR_HEADER);
  1148. frame[0] = TTP_PARAMETERS | n;
  1149. frame[1] = 0x04; /* Length */
  1150. /* irda_param_insert(self, IRTTP_MAX_SDU_SIZE, frame+1, */
  1151. /* TTP_SAR_HEADER, &param_info) */
  1152. frame[2] = 0x01; /* MaxSduSize */
  1153. frame[3] = 0x02; /* Value length */
  1154. put_unaligned(cpu_to_be16((__u16) max_sdu_size),
  1155. (__be16 *)(frame+4));
  1156. } else {
  1157. /* Insert TTP header */
  1158. frame = skb_push(tx_skb, TTP_HEADER);
  1159. frame[0] = n & 0x7f;
  1160. }
  1161. ret = irlmp_connect_response(self->lsap, tx_skb);
  1162. return ret;
  1163. }
  1164. EXPORT_SYMBOL(irttp_connect_response);
  1165. /*
  1166. * Function irttp_dup (self, instance)
  1167. *
  1168. * Duplicate TSAP, can be used by servers to confirm a connection on a
  1169. * new TSAP so it can keep listening on the old one.
  1170. */
  1171. struct tsap_cb *irttp_dup(struct tsap_cb *orig, void *instance)
  1172. {
  1173. struct tsap_cb *new;
  1174. unsigned long flags;
  1175. IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
  1176. /* Protect our access to the old tsap instance */
  1177. spin_lock_irqsave(&irttp->tsaps->hb_spinlock, flags);
  1178. /* Find the old instance */
  1179. if (!hashbin_find(irttp->tsaps, (long) orig, NULL)) {
  1180. IRDA_DEBUG(0, "%s(), unable to find TSAP\n", __FUNCTION__);
  1181. spin_unlock_irqrestore(&irttp->tsaps->hb_spinlock, flags);
  1182. return NULL;
  1183. }
  1184. /* Allocate a new instance */
  1185. new = kmalloc(sizeof(struct tsap_cb), GFP_ATOMIC);
  1186. if (!new) {
  1187. IRDA_DEBUG(0, "%s(), unable to kmalloc\n", __FUNCTION__);
  1188. spin_unlock_irqrestore(&irttp->tsaps->hb_spinlock, flags);
  1189. return NULL;
  1190. }
  1191. /* Dup */
  1192. memcpy(new, orig, sizeof(struct tsap_cb));
  1193. /* We don't need the old instance any more */
  1194. spin_unlock_irqrestore(&irttp->tsaps->hb_spinlock, flags);
  1195. /* Try to dup the LSAP (may fail if we were too slow) */
  1196. new->lsap = irlmp_dup(orig->lsap, new);
  1197. if (!new->lsap) {
  1198. IRDA_DEBUG(0, "%s(), dup failed!\n", __FUNCTION__);
  1199. kfree(new);
  1200. return NULL;
  1201. }
  1202. /* Not everything should be copied */
  1203. new->notify.instance = instance;
  1204. spin_lock_init(&new->lock);
  1205. init_timer(&new->todo_timer);
  1206. skb_queue_head_init(&new->rx_queue);
  1207. skb_queue_head_init(&new->tx_queue);
  1208. skb_queue_head_init(&new->rx_fragments);
  1209. /* This is locked */
  1210. hashbin_insert(irttp->tsaps, (irda_queue_t *) new, (long) new, NULL);
  1211. return new;
  1212. }
  1213. EXPORT_SYMBOL(irttp_dup);
  1214. /*
  1215. * Function irttp_disconnect_request (self)
  1216. *
  1217. * Close this connection please! If priority is high, the queued data
  1218. * segments, if any, will be deallocated first
  1219. *
  1220. */
  1221. int irttp_disconnect_request(struct tsap_cb *self, struct sk_buff *userdata,
  1222. int priority)
  1223. {
  1224. int ret;
  1225. IRDA_ASSERT(self != NULL, return -1;);
  1226. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
  1227. /* Already disconnected? */
  1228. if (!self->connected) {
  1229. IRDA_DEBUG(4, "%s(), already disconnected!\n", __FUNCTION__);
  1230. if (userdata)
  1231. dev_kfree_skb(userdata);
  1232. return -1;
  1233. }
  1234. /* Disconnect already pending ?
  1235. * We need to use an atomic operation to prevent reentry. This
  1236. * function may be called from various context, like user, timer
  1237. * for following a disconnect_indication() (i.e. net_bh).
  1238. * Jean II */
  1239. if(test_and_set_bit(0, &self->disconnect_pend)) {
  1240. IRDA_DEBUG(0, "%s(), disconnect already pending\n",
  1241. __FUNCTION__);
  1242. if (userdata)
  1243. dev_kfree_skb(userdata);
  1244. /* Try to make some progress */
  1245. irttp_run_tx_queue(self);
  1246. return -1;
  1247. }
  1248. /*
  1249. * Check if there is still data segments in the transmit queue
  1250. */
  1251. if (!skb_queue_empty(&self->tx_queue)) {
  1252. if (priority == P_HIGH) {
  1253. /*
  1254. * No need to send the queued data, if we are
  1255. * disconnecting right now since the data will
  1256. * not have any usable connection to be sent on
  1257. */
  1258. IRDA_DEBUG(1, "%s(): High priority!!()\n", __FUNCTION__);
  1259. irttp_flush_queues(self);
  1260. } else if (priority == P_NORMAL) {
  1261. /*
  1262. * Must delay disconnect until after all data segments
  1263. * have been sent and the tx_queue is empty
  1264. */
  1265. /* We'll reuse this one later for the disconnect */
  1266. self->disconnect_skb = userdata; /* May be NULL */
  1267. irttp_run_tx_queue(self);
  1268. irttp_start_todo_timer(self, HZ/10);
  1269. return -1;
  1270. }
  1271. }
  1272. /* Note : we don't need to check if self->rx_queue is full and the
  1273. * state of self->rx_sdu_busy because the disconnect response will
  1274. * be sent at the LMP level (so even if the peer has its Tx queue
  1275. * full of data). - Jean II */
  1276. IRDA_DEBUG(1, "%s(), Disconnecting ...\n", __FUNCTION__);
  1277. self->connected = FALSE;
  1278. if (!userdata) {
  1279. struct sk_buff *tx_skb;
  1280. tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
  1281. if (!tx_skb)
  1282. return -ENOMEM;
  1283. /*
  1284. * Reserve space for MUX and LAP header
  1285. */
  1286. skb_reserve(tx_skb, LMP_MAX_HEADER);
  1287. userdata = tx_skb;
  1288. }
  1289. ret = irlmp_disconnect_request(self->lsap, userdata);
  1290. /* The disconnect is no longer pending */
  1291. clear_bit(0, &self->disconnect_pend); /* FALSE */
  1292. return ret;
  1293. }
  1294. EXPORT_SYMBOL(irttp_disconnect_request);
  1295. /*
  1296. * Function irttp_disconnect_indication (self, reason)
  1297. *
  1298. * Disconnect indication, TSAP disconnected by peer?
  1299. *
  1300. */
  1301. void irttp_disconnect_indication(void *instance, void *sap, LM_REASON reason,
  1302. struct sk_buff *skb)
  1303. {
  1304. struct tsap_cb *self;
  1305. IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
  1306. self = (struct tsap_cb *) instance;
  1307. IRDA_ASSERT(self != NULL, return;);
  1308. IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
  1309. /* Prevent higher layer to send more data */
  1310. self->connected = FALSE;
  1311. /* Check if client has already tried to close the TSAP */
  1312. if (self->close_pend) {
  1313. /* In this case, the higher layer is probably gone. Don't
  1314. * bother it and clean up the remains - Jean II */
  1315. if (skb)
  1316. dev_kfree_skb(skb);
  1317. irttp_close_tsap(self);
  1318. return;
  1319. }
  1320. /* If we are here, we assume that is the higher layer is still
  1321. * waiting for the disconnect notification and able to process it,
  1322. * even if he tried to disconnect. Otherwise, it would have already
  1323. * attempted to close the tsap and self->close_pend would be TRUE.
  1324. * Jean II */
  1325. /* No need to notify the client if has already tried to disconnect */
  1326. if(self->notify.disconnect_indication)
  1327. self->notify.disconnect_indication(self->notify.instance, self,
  1328. reason, skb);
  1329. else
  1330. if (skb)
  1331. dev_kfree_skb(skb);
  1332. }
  1333. /*
  1334. * Function irttp_do_data_indication (self, skb)
  1335. *
  1336. * Try to deliver reassembled skb to layer above, and requeue it if that
  1337. * for some reason should fail. We mark rx sdu as busy to apply back
  1338. * pressure is necessary.
  1339. */
  1340. static void irttp_do_data_indication(struct tsap_cb *self, struct sk_buff *skb)
  1341. {
  1342. int err;
  1343. /* Check if client has already closed the TSAP and gone away */
  1344. if (self->close_pend) {
  1345. dev_kfree_skb(skb);
  1346. return;
  1347. }
  1348. err = self->notify.data_indication(self->notify.instance, self, skb);
  1349. /* Usually the layer above will notify that it's input queue is
  1350. * starting to get filled by using the flow request, but this may
  1351. * be difficult, so it can instead just refuse to eat it and just
  1352. * give an error back
  1353. */
  1354. if (err) {
  1355. IRDA_DEBUG(0, "%s() requeueing skb!\n", __FUNCTION__);
  1356. /* Make sure we take a break */
  1357. self->rx_sdu_busy = TRUE;
  1358. /* Need to push the header in again */
  1359. skb_push(skb, TTP_HEADER);
  1360. skb->data[0] = 0x00; /* Make sure MORE bit is cleared */
  1361. /* Put skb back on queue */
  1362. skb_queue_head(&self->rx_queue, skb);
  1363. }
  1364. }
  1365. /*
  1366. * Function irttp_run_rx_queue (self)
  1367. *
  1368. * Check if we have any frames to be transmitted, or if we have any
  1369. * available credit to give away.
  1370. */
  1371. void irttp_run_rx_queue(struct tsap_cb *self)
  1372. {
  1373. struct sk_buff *skb;
  1374. int more = 0;
  1375. IRDA_DEBUG(2, "%s() send=%d,avail=%d,remote=%d\n", __FUNCTION__,
  1376. self->send_credit, self->avail_credit, self->remote_credit);
  1377. /* Get exclusive access to the rx queue, otherwise don't touch it */
  1378. if (irda_lock(&self->rx_queue_lock) == FALSE)
  1379. return;
  1380. /*
  1381. * Reassemble all frames in receive queue and deliver them
  1382. */
  1383. while (!self->rx_sdu_busy && (skb = skb_dequeue(&self->rx_queue))) {
  1384. /* This bit will tell us if it's the last fragment or not */
  1385. more = skb->data[0] & 0x80;
  1386. /* Remove TTP header */
  1387. skb_pull(skb, TTP_HEADER);
  1388. /* Add the length of the remaining data */
  1389. self->rx_sdu_size += skb->len;
  1390. /*
  1391. * If SAR is disabled, or user has requested no reassembly
  1392. * of received fragments then we just deliver them
  1393. * immediately. This can be requested by clients that
  1394. * implements byte streams without any message boundaries
  1395. */
  1396. if (self->rx_max_sdu_size == TTP_SAR_DISABLE) {
  1397. irttp_do_data_indication(self, skb);
  1398. self->rx_sdu_size = 0;
  1399. continue;
  1400. }
  1401. /* Check if this is a fragment, and not the last fragment */
  1402. if (more) {
  1403. /*
  1404. * Queue the fragment if we still are within the
  1405. * limits of the maximum size of the rx_sdu
  1406. */
  1407. if (self->rx_sdu_size <= self->rx_max_sdu_size) {
  1408. IRDA_DEBUG(4, "%s(), queueing frag\n",
  1409. __FUNCTION__);
  1410. skb_queue_tail(&self->rx_fragments, skb);
  1411. } else {
  1412. /* Free the part of the SDU that is too big */
  1413. dev_kfree_skb(skb);
  1414. }
  1415. continue;
  1416. }
  1417. /*
  1418. * This is the last fragment, so time to reassemble!
  1419. */
  1420. if ((self->rx_sdu_size <= self->rx_max_sdu_size) ||
  1421. (self->rx_max_sdu_size == TTP_SAR_UNBOUND))
  1422. {
  1423. /*
  1424. * A little optimizing. Only queue the fragment if
  1425. * there are other fragments. Since if this is the
  1426. * last and only fragment, there is no need to
  1427. * reassemble :-)
  1428. */
  1429. if (!skb_queue_empty(&self->rx_fragments)) {
  1430. skb_queue_tail(&self->rx_fragments,
  1431. skb);
  1432. skb = irttp_reassemble_skb(self);
  1433. }
  1434. /* Now we can deliver the reassembled skb */
  1435. irttp_do_data_indication(self, skb);
  1436. } else {
  1437. IRDA_DEBUG(1, "%s(), Truncated frame\n", __FUNCTION__);
  1438. /* Free the part of the SDU that is too big */
  1439. dev_kfree_skb(skb);
  1440. /* Deliver only the valid but truncated part of SDU */
  1441. skb = irttp_reassemble_skb(self);
  1442. irttp_do_data_indication(self, skb);
  1443. }
  1444. self->rx_sdu_size = 0;
  1445. }
  1446. /*
  1447. * It's not trivial to keep track of how many credits are available
  1448. * by incrementing at each packet, because delivery may fail
  1449. * (irttp_do_data_indication() may requeue the frame) and because
  1450. * we need to take care of fragmentation.
  1451. * We want the other side to send up to initial_credit packets.
  1452. * We have some frames in our queues, and we have already allowed it
  1453. * to send remote_credit.
  1454. * No need to spinlock, write is atomic and self correcting...
  1455. * Jean II
  1456. */
  1457. self->avail_credit = (self->initial_credit -
  1458. (self->remote_credit +
  1459. skb_queue_len(&self->rx_queue) +
  1460. skb_queue_len(&self->rx_fragments)));
  1461. /* Do we have too much credits to send to peer ? */
  1462. if ((self->remote_credit <= TTP_RX_MIN_CREDIT) &&
  1463. (self->avail_credit > 0)) {
  1464. /* Send explicit credit frame */
  1465. irttp_give_credit(self);
  1466. /* Note : do *NOT* check if tx_queue is non-empty, that
  1467. * will produce deadlocks. I repeat : send a credit frame
  1468. * even if we have something to send in our Tx queue.
  1469. * If we have credits, it means that our Tx queue is blocked.
  1470. *
  1471. * Let's suppose the peer can't keep up with our Tx. He will
  1472. * flow control us by not sending us any credits, and we
  1473. * will stop Tx and start accumulating credits here.
  1474. * Up to the point where the peer will stop its Tx queue,
  1475. * for lack of credits.
  1476. * Let's assume the peer application is single threaded.
  1477. * It will block on Tx and never consume any Rx buffer.
  1478. * Deadlock. Guaranteed. - Jean II
  1479. */
  1480. }
  1481. /* Reset lock */
  1482. self->rx_queue_lock = 0;
  1483. }
  1484. #ifdef CONFIG_PROC_FS
  1485. struct irttp_iter_state {
  1486. int id;
  1487. };
  1488. static void *irttp_seq_start(struct seq_file *seq, loff_t *pos)
  1489. {
  1490. struct irttp_iter_state *iter = seq->private;
  1491. struct tsap_cb *self;
  1492. /* Protect our access to the tsap list */
  1493. spin_lock_irq(&irttp->tsaps->hb_spinlock);
  1494. iter->id = 0;
  1495. for (self = (struct tsap_cb *) hashbin_get_first(irttp->tsaps);
  1496. self != NULL;
  1497. self = (struct tsap_cb *) hashbin_get_next(irttp->tsaps)) {
  1498. if (iter->id == *pos)
  1499. break;
  1500. ++iter->id;
  1501. }
  1502. return self;
  1503. }
  1504. static void *irttp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  1505. {
  1506. struct irttp_iter_state *iter = seq->private;
  1507. ++*pos;
  1508. ++iter->id;
  1509. return (void *) hashbin_get_next(irttp->tsaps);
  1510. }
  1511. static void irttp_seq_stop(struct seq_file *seq, void *v)
  1512. {
  1513. spin_unlock_irq(&irttp->tsaps->hb_spinlock);
  1514. }
  1515. static int irttp_seq_show(struct seq_file *seq, void *v)
  1516. {
  1517. const struct irttp_iter_state *iter = seq->private;
  1518. const struct tsap_cb *self = v;
  1519. seq_printf(seq, "TSAP %d, ", iter->id);
  1520. seq_printf(seq, "stsap_sel: %02x, ",
  1521. self->stsap_sel);
  1522. seq_printf(seq, "dtsap_sel: %02x\n",
  1523. self->dtsap_sel);
  1524. seq_printf(seq, " connected: %s, ",
  1525. self->connected? "TRUE":"FALSE");
  1526. seq_printf(seq, "avail credit: %d, ",
  1527. self->avail_credit);
  1528. seq_printf(seq, "remote credit: %d, ",
  1529. self->remote_credit);
  1530. seq_printf(seq, "send credit: %d\n",
  1531. self->send_credit);
  1532. seq_printf(seq, " tx packets: %ld, ",
  1533. self->stats.tx_packets);
  1534. seq_printf(seq, "rx packets: %ld, ",
  1535. self->stats.rx_packets);
  1536. seq_printf(seq, "tx_queue len: %d ",
  1537. skb_queue_len(&self->tx_queue));
  1538. seq_printf(seq, "rx_queue len: %d\n",
  1539. skb_queue_len(&self->rx_queue));
  1540. seq_printf(seq, " tx_sdu_busy: %s, ",
  1541. self->tx_sdu_busy? "TRUE":"FALSE");
  1542. seq_printf(seq, "rx_sdu_busy: %s\n",
  1543. self->rx_sdu_busy? "TRUE":"FALSE");
  1544. seq_printf(seq, " max_seg_size: %d, ",
  1545. self->max_seg_size);
  1546. seq_printf(seq, "tx_max_sdu_size: %d, ",
  1547. self->tx_max_sdu_size);
  1548. seq_printf(seq, "rx_max_sdu_size: %d\n",
  1549. self->rx_max_sdu_size);
  1550. seq_printf(seq, " Used by (%s)\n\n",
  1551. self->notify.name);
  1552. return 0;
  1553. }
  1554. static struct seq_operations irttp_seq_ops = {
  1555. .start = irttp_seq_start,
  1556. .next = irttp_seq_next,
  1557. .stop = irttp_seq_stop,
  1558. .show = irttp_seq_show,
  1559. };
  1560. static int irttp_seq_open(struct inode *inode, struct file *file)
  1561. {
  1562. struct seq_file *seq;
  1563. int rc = -ENOMEM;
  1564. struct irttp_iter_state *s;
  1565. s = kzalloc(sizeof(*s), GFP_KERNEL);
  1566. if (!s)
  1567. goto out;
  1568. rc = seq_open(file, &irttp_seq_ops);
  1569. if (rc)
  1570. goto out_kfree;
  1571. seq = file->private_data;
  1572. seq->private = s;
  1573. out:
  1574. return rc;
  1575. out_kfree:
  1576. kfree(s);
  1577. goto out;
  1578. }
  1579. const struct file_operations irttp_seq_fops = {
  1580. .owner = THIS_MODULE,
  1581. .open = irttp_seq_open,
  1582. .read = seq_read,
  1583. .llseek = seq_lseek,
  1584. .release = seq_release_private,
  1585. };
  1586. #endif /* PROC_FS */