1. diff --git a/.config b/.config
  2. index c7188ac..569621f 100644
  3. --- a/.config
  4. +++ b/.config
  5. @@ -1601,6 +1601,13 @@ CONFIG_BT_MRVL=m
  6. CONFIG_BT_MRVL_SDIO=m
  7. CONFIG_BT_ATH3K=m
  8. CONFIG_BT_WILINK=m
  9. +CONFIG_DECT=m
  10. +CONFIG_DECT_DEBUG=y
  11. +CONFIG_DECT_CSF=m
  12. +CONFIG_DECT_RAW=m
  13. +CONFIG_DECT_CCF=m
  14. +CONFIG_DECT_LU1_SAP=m
  15. +# CONFIG_DECT_CCP is not set
  16. CONFIG_AF_RXRPC=m
  17. # CONFIG_AF_RXRPC_IPV6 is not set
  18. # CONFIG_AF_RXRPC_INJECT_LOSS is not set
  19. @@ -3179,6 +3186,15 @@ CONFIG_NVM=y
  20. # CONFIG_NVM_DEBUG is not set
  21. CONFIG_NVM_GENNVM=m
  22. CONFIG_NVM_RRPC=m
  23. +CONFIG_DECTDEVICES=y
  24. +CONFIG_DECT_VTRX=m
  25. +CONFIG_DECT_COA_PCI=m
  26. +CONFIG_DECT_COA_CS=m
  27. +CONFIG_DECT_COA=m
  28. +CONFIG_DECT_COA_U2785=y
  29. +CONFIG_DECT_COA_LMX3161=y
  30. +CONFIG_DECT_COA_FIRMWARE=y
  31. +CONFIG_DECT_COA_P64=y
  33. #
  34. # Input device support
  35. diff --git a/MAINTAINERS b/MAINTAINERS
  36. index 52cc077..3f5e377 100644
  37. --- a/MAINTAINERS
  38. +++ b/MAINTAINERS
  39. @@ -3681,6 +3681,14 @@ F: arch/mips/dec/
  40. F: arch/mips/include/asm/dec/
  41. F: arch/mips/include/asm/mach-dec/
  43. +DECT NETWORK PROTOCOL
  44. +M: Patrick McHardy <kaber@trash.net>
  45. +S: Maintained
  46. +F: net/dect
  47. +F: drivers/dect
  48. +F: include/net/dect
  49. +F: include/linux/dect*.h
  50. +
  51. DEFXX FDDI NETWORK DRIVER
  52. M: "Maciej W. Rozycki" <macro@linux-mips.org>
  53. S: Maintained
  54. diff --git a/drivers/Kconfig b/drivers/Kconfig
  55. index e1e2066..6eb8f71 100644
  56. --- a/drivers/Kconfig
  57. +++ b/drivers/Kconfig
  58. @@ -46,6 +46,8 @@ source "drivers/isdn/Kconfig"
  60. source "drivers/lightnvm/Kconfig"
  62. +source "drivers/dect/Kconfig"
  63. +
  64. # input before char - char/joystick depends on it. As does USB.
  66. source "drivers/input/Kconfig"
  67. diff --git a/drivers/Makefile b/drivers/Makefile
  68. index 194d20b..e11eca1 100644
  69. --- a/drivers/Makefile
  70. +++ b/drivers/Makefile
  71. @@ -117,6 +117,7 @@ obj-$(CONFIG_MD) += md/
  72. obj-$(CONFIG_BT) += bluetooth/
  73. obj-$(CONFIG_ACCESSIBILITY) += accessibility/
  74. obj-$(CONFIG_ISDN) += isdn/
  75. +obj-$(CONFIG_DECT) += dect/
  76. obj-$(CONFIG_EDAC) += edac/
  77. obj-$(CONFIG_EISA) += eisa/
  78. obj-y += lguest/
  79. diff --git a/drivers/dect/Kconfig b/drivers/dect/Kconfig
  80. new file mode 100644
  81. index 0000000..baba4c1
  82. --- /dev/null
  83. +++ b/drivers/dect/Kconfig
  84. @@ -0,0 +1,11 @@
  85. +menuconfig DECTDEVICES
  86. + bool "DECT device support"
  87. + help
  88. + Say Y here to show DECT device driver options.
  89. +
  90. +if DECTDEVICES
  91. +
  92. +source "drivers/dect/vtrx/Kconfig"
  93. +source "drivers/dect/coa/Kconfig"
  94. +
  95. +endif
  96. diff --git a/drivers/dect/Makefile b/drivers/dect/Makefile
  97. new file mode 100644
  98. index 0000000..c58af58
  99. --- /dev/null
  100. +++ b/drivers/dect/Makefile
  101. @@ -0,0 +1,2 @@
  102. +obj-$(CONFIG_DECT_VTRX) += vtrx/
  103. +obj-$(CONFIG_DECT_COA) += coa/
  104. diff --git a/drivers/dect/coa/.gitignore b/drivers/dect/coa/.gitignore
  105. new file mode 100644
  106. index 0000000..7890f99
  107. --- /dev/null
  108. +++ b/drivers/dect/coa/.gitignore
  109. @@ -0,0 +1,4 @@
  110. +bin2c
  111. +*.p
  112. +*.h.tmp
  113. +*.bin
  114. diff --git a/drivers/dect/coa/Kconfig b/drivers/dect/coa/Kconfig
  115. new file mode 100644
  116. index 0000000..207193f
  117. --- /dev/null
  118. +++ b/drivers/dect/coa/Kconfig
  119. @@ -0,0 +1,45 @@
  120. +config DECT_COA_PCI
  121. + tristate "Com-on-Air PCI DECT support"
  122. + depends on DECT
  123. + depends on PCI
  124. + select DECT_COA
  125. + select DECT_COA_U2785
  126. + help
  127. + This option enables support for the Com-on-Air DECT PCI devices.
  128. +
  129. +config DECT_COA_CS
  130. + tristate "Com-on-Air PCMCIA DECT support"
  131. + depends on DECT
  132. + depends on PCMCIA
  133. + select DECT_COA
  134. + select DECT_COA_U2785
  135. + select DECT_COA_LMX3161
  136. + select CRC32
  137. + help
  138. + This option enables support for the Com-on-Air DECT PCMCIA devices.
  139. +
  140. +config DECT_COA
  141. + tristate
  142. +
  143. +config DECT_COA_U2785
  144. + bool
  145. +
  146. +config DECT_COA_LMX3161
  147. + bool
  148. +
  149. +config DECT_COA_FIRMWARE
  150. + bool "Build Com-on-Air firmware (requires ASL macro assembler)"
  151. + depends on DECT_COA
  152. + help
  153. + This option enables rebuild of the firmware for the Com-on-Air
  154. + devices during the kernel build process. The ASL macro compiler
  155. + is required for this.
  156. +
  157. + If unsure, say N.
  158. +
  159. +config DECT_COA_P64
  160. + depends on DECT_COA_PCI && !DECT_COA_CS && DECT_COA_FIRMWARE
  161. + bool "Enable P640 (wideband) support"
  162. + help
  163. + This option enables support for P640j packets, which are used for
  164. + wideband audio. This does not work with the PCMCIA devices.
  165. diff --git a/drivers/dect/coa/Makefile b/drivers/dect/coa/Makefile
  166. new file mode 100644
  167. index 0000000..30033b3
  168. --- /dev/null
  169. +++ b/drivers/dect/coa/Makefile
  170. @@ -0,0 +1,44 @@
  171. +com_on_air-objs := sc1442x_firmware.o sc1442x.o
  172. +com_on_air-$(CONFIG_DECT_COA_U2785) += radio_u2785.o
  173. +com_on_air-$(CONFIG_DECT_COA_LMX3161) += radio_lmx3161.o
  174. +
  175. +obj-$(CONFIG_DECT_COA) += com_on_air.o
  176. +obj-$(CONFIG_DECT_COA_PCI) += com_on_air_pci.o
  177. +obj-$(CONFIG_DECT_COA_CS) += com_on_air_cs.o
  178. +
  179. +$(obj)/sc1442x.o: $(obj)/sc1442x_firmware.c
  180. +$(obj)/sc1442x_firmware.c: NAME=sc1442x
  181. +clean-files += sc1442x_firmware.p
  182. +clean-files += sc1442x_firmware.bin
  183. +clean-files += sc1442x_firmware.h.tmp
  184. +
  185. +hostprogs-$(CONFIG_DECT_COA_FIRMWARE) += bin2c
  186. +
  187. +ifeq ($(CONFIG_DECT_COA_FIRMWARE),y)
  188. +ifeq ($(CONFIG_DECT_COA_P64),y)
  189. +ASL_FLAGS = -D ENABLE_P64
  190. +endif
  191. +
  192. +ASL = asl
  193. +P2BIN = p2bin
  194. +BIN2C = $(obj)/bin2c
  195. +
  196. +quiet_cmd_asl = ASL $<
  197. + cmd_asl = $(ASL) -q -c $< -o $(<:.asm=.p) $(ASL_FLAGS) -shareout $(<:.asm=.h.tmp); \
  198. + $(P2BIN) $(<:.asm=.p) $(<:.asm=.bin) -r 0-509; \
  199. + $(BIN2C) $(<:.asm=.bin) $(NAME)_firmware > $@; \
  200. + ( \
  201. + echo "\#ifndef $$(echo $(NAME) | tr a-z A-Z)_FIRMWARE"; \
  202. + echo "\#define $$(echo $(NAME) | tr a-z A-Z)_FIRMWARE"; \
  203. + echo;\
  204. + echo "extern const unsigned char $(NAME)_firmware[510];"; \
  205. + echo;\
  206. + grep -a define $(<:.asm=.h.tmp); \
  207. + echo;\
  208. + echo "\#endif /* $$(echo $(NAME) | tr a-z A-Z)_FIRMWARE */"; \
  209. + ) > $(@:.c=.h)
  210. +
  211. +$(obj)/%_firmware.c: $(src)/%_firmware.asm $(BIN2C)
  212. + $(call if_changed,asl)
  213. +
  214. +endif
  215. diff --git a/drivers/dect/coa/bin2c.c b/drivers/dect/coa/bin2c.c
  216. new file mode 100644
  217. index 0000000..bab08fa
  218. --- /dev/null
  219. +++ b/drivers/dect/coa/bin2c.c
  220. @@ -0,0 +1,57 @@
  221. +#include <stdio.h>
  222. +#include <sys/types.h>
  223. +#include <sys/stat.h>
  224. +#include <fcntl.h>
  225. +#include <string.h>
  226. +#include <errno.h>
  227. +#include <stdint.h>
  228. +#include <stdlib.h>
  229. +#include <unistd.h>
  230. +
  231. +#define HEADER_FMT \
  232. + "/*\n" \
  233. + " * automatically generated file\n" \
  234. + " * DO NOT EDIT\n" \
  235. + " * edit firmware/filename.asm instead\n" \
  236. + " */\n" \
  237. + "\n" \
  238. + "#include \"%s.h\"\n" \
  239. + "\n" \
  240. + "const unsigned char %s[] = {\n"
  241. +
  242. +#define FOOTER "};\n"
  243. +
  244. +int main(int argc, char *argv[])
  245. +{
  246. + uint32_t wordcount = 0;
  247. + uint16_t w;
  248. + int f;
  249. +
  250. + if (argc < 3) {
  251. + printf("usage: bin2c bin-file varname > c-file\n");
  252. + exit(1);
  253. + }
  254. +
  255. + f = open(argv[1], O_RDONLY);
  256. + if (f < 0) {
  257. + printf("cant open(\"%s\"): %s\n", argv[1], strerror(errno));
  258. + exit(1);
  259. + }
  260. +
  261. + printf(HEADER_FMT, argv[2], argv[2]);
  262. +
  263. + while (2 == read(f, &w, 2)) {
  264. + if (!wordcount)
  265. + printf("\t");
  266. + else
  267. + if (!(wordcount % 4))
  268. + printf(",\n\t");
  269. + else
  270. + printf(", ");
  271. + printf("0x%.2x, 0x%.2x", (w & 0xff00) >> 8, w & 0xff);
  272. + wordcount++;
  273. + }
  274. + printf(FOOTER);
  275. + close(f);
  276. + return 0;
  277. +}
  278. diff --git a/drivers/dect/coa/com_on_air.h b/drivers/dect/coa/com_on_air.h
  279. new file mode 100644
  280. index 0000000..37c2b0a
  281. --- /dev/null
  282. +++ b/drivers/dect/coa/com_on_air.h
  283. @@ -0,0 +1,99 @@
  284. +/*
  285. + * com_on_air - basic driver for the Dosch and Amand "com on air" cards
  286. + *
  287. + * This program is free software; you can redistribute it and/or modify
  288. + * it under the terms of the GNU General Public License version 2 as
  289. + * published by the Free Software Foundation.
  290. + *
  291. + * authors:
  292. + * (C) 2008 Andreas Schuler <krater at badterrorist dot com>
  293. + * (C) 2008 Matthias Wenzel <dect at mazzoo dot de>
  294. + * (C) 2009 Patrick McHardy <[email protected]>
  295. + *
  296. + */
  297. +
  298. +#ifndef COM_ON_AIR_H
  299. +#define COM_ON_AIR_H
  300. +
  301. +#include <linux/types.h>
  302. +
  303. +struct coa_freq_map_entry {
  304. + struct {
  305. + u8 divisor;
  306. + u8 swcnt;
  307. + } rx, tx;
  308. +};
  309. +
  310. +struct coa_freq_map {
  311. + struct coa_freq_map_entry carrier[DECT_CARRIER_NUM];
  312. +};
  313. +
  314. +struct coa_device;
  315. +struct coa_radio_ops {
  316. + void (*rx_init)(const struct coa_device *dev, u16 offset);
  317. + void (*tx_init)(const struct coa_device *dev, u16 offset);
  318. + void (*set_carrier)(const struct coa_device *dev, u16 offset,
  319. + enum dect_slot_states mode, u8 carrier);
  320. + u64 (*map_band)(struct coa_device *dev,
  321. + const struct dect_band *band);
  322. + const char *type;
  323. +};
  324. +
  325. +extern const struct coa_radio_ops coa_u2785_radio_ops;
  326. +extern const struct coa_radio_ops coa_lmx3161_radio_ops;
  327. +
  328. +/**
  329. + * struct sc1442x_phase_state - per-slot phase offset state
  330. + *
  331. + * @framenum: frame number the information was last updated
  332. + * @tap: sc1442x internal clock cycle which sampled the data
  333. + * @phase: offset of number of symbol periods to nominal 11520 symbols per frame
  334. + *
  335. + * This structure is used to store the measured values for one particular
  336. + * frame. The actual phase offset is calculated from the differences of two
  337. + * consequitive frames.
  338. + */
  339. +struct sc1442x_phase_state {
  340. + u8 framenum;
  341. + u8 tap;
  342. + s8 phase;
  343. +};
  344. +
  345. +enum coa_device_types {
  346. + COA_TYPE_PCI,
  347. + COA_TYPE_PCMCIA,
  348. +};
  349. +
  350. +struct coa_device {
  351. + const struct device *dev;
  352. + unsigned int irq;
  353. +
  354. + enum coa_device_types type;
  355. +
  356. + const struct coa_radio_ops *radio_ops;
  357. + struct coa_freq_map freq_map;
  358. + struct sc1442x_phase_state phase_state[DECT_FRAME_SIZE / 2];
  359. +
  360. + spinlock_t lock;
  361. + uint config_base;
  362. + u8 __iomem *sc1442x_base;
  363. + u16 cfg_reg;
  364. + u16 irq_reg;
  365. + u16 code_base;
  366. + u16 data_base;
  367. + u16 data_mask;
  368. +
  369. + u8 ctrl;
  370. + u8 led;
  371. +};
  372. +
  373. +extern irqreturn_t sc1442x_interrupt(int irq, void *dev_id);
  374. +extern const struct dect_transceiver_ops sc1442x_transceiver_ops;
  375. +
  376. +extern int sc1442x_init_device(struct coa_device *dev);
  377. +extern void sc1442x_shutdown_device(struct coa_device *dev);
  378. +
  379. +extern void sc1442x_rfdesc_write(const struct coa_device *dev, u16 offset,
  380. + const u8 *src, u16 length);
  381. +
  382. +#endif
  383. diff --git a/drivers/dect/coa/com_on_air_cs.c b/drivers/dect/coa/com_on_air_cs.c
  384. new file mode 100644
  385. index 0000000..e1f2231
  386. --- /dev/null
  387. +++ b/drivers/dect/coa/com_on_air_cs.c
  388. @@ -0,0 +1,271 @@
  389. +/*
  390. + * com_on_air_cs - basic driver for the Dosch and Amand "com on air" cards
  391. + *
  392. + * This program is free software; you can redistribute it and/or modify
  393. + * it under the terms of the GNU General Public License version 2 as
  394. + * published by the Free Software Foundation.
  395. + *
  396. + * authors:
  397. + * (C) 2008 Andreas Schuler <krater at badterrorist dot com>
  398. + * (C) 2008 Matthias Wenzel <dect at mazzoo dot de>
  399. + * (C) 2009 Patrick McHardy <[email protected]>
  400. + *
  401. + */
  402. +
  403. +#include <linux/kernel.h>
  404. +#include <linux/module.h>
  405. +#include <linux/interrupt.h>
  406. +#include <linux/init.h>
  407. +#include <linux/crc32.h>
  408. +#include <net/dect/transceiver.h>
  409. +
  410. +#include <pcmcia/cistpl.h>
  411. +#include <pcmcia/ciscode.h>
  412. +#include <pcmcia/ds.h>
  413. +#include <pcmcia/cisreg.h>
  414. +
  415. +#include "com_on_air.h"
  416. +
  417. +MODULE_AUTHOR("Matthias Wenzel comonair<a>mazzoo.de;"
  418. + "Andreas Schuler dect<a>badterrorist.com");
  419. +MODULE_DESCRIPTION("Dosch&Amand COM-ON-AIR PCMCIA driver");
  420. +MODULE_LICENSE("GPL");
  421. +
  422. +static int get_card_id(const struct pcmcia_device *link);
  423. +
  424. +static int com_on_air_probe(struct pcmcia_device *link)
  425. +{
  426. + struct dect_transceiver *trx;
  427. + struct coa_device *dev;
  428. + int err;
  429. +
  430. + trx = dect_transceiver_alloc(&sc1442x_transceiver_ops, sizeof(*dev));
  431. + if (!trx) {
  432. + err = -ENOMEM;
  433. + goto err1;
  434. + }
  435. +
  436. + link->priv = trx;
  437. + dev = dect_transceiver_priv(trx);
  438. + dev->type = COA_TYPE_PCMCIA;
  439. + dev->code_base = 0x0;
  440. + dev->data_base = 0x0;
  441. + dev->data_mask = 0x0ff;
  442. + dev->cfg_reg = 0x1ff;
  443. + dev->irq_reg = 0x0;
  444. + dev->dev = &link->dev;
  445. +
  446. + dev_info(dev->dev, "%s %s %s %s\n", link->prod_id[0], link->prod_id[1],
  447. + link->prod_id[2] ? : "", link->prod_id[3] ? : "");
  448. +
  449. + link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
  450. + link->resource[0]->end = 16;
  451. + link->resource[1]->flags |= 0;
  452. +
  453. + link->config_flags = CONF_ENABLE_IRQ;
  454. + link->config_index = 1;
  455. + link->config_regs = PRESENT_OPTION;
  456. + link->config_base = 0x1020;
  457. +
  458. + link->resource[2]->flags = WIN_DATA_WIDTH_16 | WIN_ENABLE;
  459. + link->resource[2]->start = 0;
  460. + link->resource[2]->end = 0x1000;
  461. +
  462. + err = pcmcia_request_window(link, link->resource[2], 500);
  463. + if (err < 0) {
  464. + dev_err(dev->dev, "failed to obtain PCMCIA window\n");
  465. + goto err2;
  466. + }
  467. +
  468. + dev->sc1442x_base = ioremap_nocache(link->resource[2]->start,
  469. + resource_size(link->resource[2]));
  470. + if (!dev->sc1442x_base) {
  471. + dev_err(dev->dev, "failed to remap PCMCIA resource\n");
  472. + err = -EIO;
  473. + goto err3;
  474. + }
  475. +
  476. + link->socket->functions = 0;
  477. +
  478. + err = pcmcia_request_irq(link, sc1442x_interrupt);
  479. + if (err < 0) {
  480. + dev_err(dev->dev, "failed to request IRQ%d\n", link->irq);
  481. + goto err4;
  482. + }
  483. +
  484. + err = pcmcia_enable_device(link);
  485. + if (err < 0) {
  486. + dev_err(dev->dev, "failed to enable PCMCIA device\n");
  487. + goto err5;
  488. + }
  489. +
  490. + dev_dbg(dev->dev, "%svalid client.\n", (link->config_flags) ? "":"in");
  491. + dev_dbg(dev->dev, "Type 0x%x\n", link->socket->state);
  492. + dev_dbg(dev->dev, "Function 0x%x\n", link->func);
  493. + dev_dbg(dev->dev, "config_flags %d\n", link->config_flags);
  494. + dev_dbg(dev->dev, "config_base 0x%x\n", link->config_base);
  495. + dev_dbg(dev->dev, "config_regs %d\n", link->config_regs);
  496. + dev_dbg(dev->dev, "IRQ 0x%x\n", link->irq);
  497. + dev_dbg(dev->dev, "BasePort1 0x%llx\n", link->resource[0]->start);
  498. + dev_dbg(dev->dev, "NumPorts1 0x%llx\n", link->resource[0]->end);
  499. + dev_dbg(dev->dev, "Attributes1 0x%lx\n", link->resource[0]->flags);
  500. + dev_dbg(dev->dev, "BasePort2 0x%llx\n", link->resource[1]->start);
  501. + dev_dbg(dev->dev, "NumPorts2 0x%llx\n", link->resource[1]->end);
  502. + dev_dbg(dev->dev, "Attributes2 0x%lx\n", link->resource[1]->flags);
  503. + dev_dbg(dev->dev, "IOAddrLines 0x%x\n", link->io_lines);
  504. + dev_dbg(dev->dev, "has%s function_config\n",
  505. + link->function_config ? "":" no");
  506. +
  507. + switch (get_card_id(link)) {
  508. + case 0:
  509. + case 3:
  510. + dev->radio_ops = &coa_u2785_radio_ops;
  511. + break;
  512. + case 1:
  513. + case 2:
  514. + dev->radio_ops = &coa_lmx3161_radio_ops;
  515. + break;
  516. + default:
  517. + dev_err(dev->dev, "unknown radio type\n");
  518. + err = -EINVAL;
  519. + goto err5;
  520. + }
  521. +
  522. + dev_info(dev->dev, "Radio type %s\n", dev->radio_ops->type);
  523. +
  524. + dev->irq = link->irq;
  525. + dev->config_base = link->config_base;
  526. + err = sc1442x_init_device(dev);
  527. + if (err < 0)
  528. + goto err5;
  529. +
  530. + err = dect_register_transceiver(trx);
  531. + if (err < 0)
  532. + goto err6;
  533. +
  534. + return 0;
  535. +
  536. +err6:
  537. + sc1442x_shutdown_device(dev);
  538. +err5:
  539. + pcmcia_disable_device(link);
  540. +err4:
  541. + iounmap(dev->sc1442x_base);
  542. +err3:
  543. + pcmcia_release_window(link, link->resource[2]);
  544. +err2:
  545. + dect_transceiver_free(trx);
  546. +err1:
  547. + return err;
  548. +}
  549. +
  550. +static void com_on_air_remove(struct pcmcia_device *link)
  551. +{
  552. + struct dect_transceiver *trx = link->priv;
  553. + struct coa_device *dev = dect_transceiver_priv(trx);
  554. + u8 __iomem *sc1442x_base = dev->sc1442x_base;
  555. +
  556. + sc1442x_shutdown_device(dev);
  557. + pcmcia_disable_device(link);
  558. + dect_unregister_transceiver(trx);
  559. + iounmap(sc1442x_base);
  560. +}
  561. +
  562. +static int com_on_air_suspend(struct pcmcia_device *link)
  563. +{
  564. + struct dect_transceiver *trx = link->priv;
  565. + struct coa_device *dev = dect_transceiver_priv(trx);
  566. +
  567. + sc1442x_shutdown_device(dev);
  568. + return 0;
  569. +}
  570. +
  571. +static int com_on_air_resume(struct pcmcia_device *link)
  572. +{
  573. + struct dect_transceiver *trx = link->priv;
  574. + struct coa_device *dev = dect_transceiver_priv(trx);
  575. +
  576. + return sc1442x_init_device(dev);
  577. +}
  578. +
  579. +static struct pcmcia_device_id com_on_air_ids[] = {
  580. + /*
  581. + * The crc32 hashes below are generated by the tool in
  582. + * Documentation/pcmcia/devicetable.txt
  583. + */
  584. + PCMCIA_DEVICE_PROD_ID12 ("DECTDataDevice", "PCMCIA F22",
  585. + 0x11fe69e9, 0x253670b2),
  586. + PCMCIA_DEVICE_PROD_ID12 ("DECTDataDevice", "PCMCIA",
  587. + 0x11fe69e9, 0x281f1c5d),
  588. + PCMCIA_DEVICE_PROD_ID1234("DOSCH-AMAND", "MMAP PCMCIA",
  589. + "MXM500", "V1.00",
  590. + 0x4bc552e7, 0x0df519bb,
  591. + 0x09e43c7c, 0x3488c81a),
  592. + PCMCIA_DEVICE_PROD_ID12 ("DECTVoIPDevice", "PCMCIA DA099",
  593. + 0xeabb0be4, 0xd7b915fe),
  594. +#if 0
  595. + There are more devices out there, I only own the above three.
  596. + an excerpt from win32 dna.inf:
  597. +
  598. +%String1%=pcmcia.install,PCMCIA\DOSCH-AMAND-MMAP_PCMCIA-C7D7
  599. +%String1%=pcmcia.install,PCMCIA\Dosch-Amand-DECT_MultiMedia-BD0D
  600. +%String1%=pcmcia.install,PCMCIA\DOSCH_&_AMAND-DECT_MULTIMEDIA-1A9F
  601. +%String1%=pcmcia.install,PCMCIA\DECTDataDevice-F13-6433
  602. +%String1%=pcmcia.install,PCMCIA\DECTDataDevice-PCMCIA-0EF8
  603. +%String4%=pci.install,PCI\VEN_11E3&DEV_0001&SUBSYS_000111E3&REV_00
  604. +%String4%=pci.install,PCI\VEN_11E3&DEV_0001&SUBSYS_00011786&REV_32
  605. +%String4%=pci.install,PCI\VEN_1786&DEV_0001&SUBSYS_000111E3&REV_00
  606. +%String5%=freekey2.install,PCMCIA\DECTDataDevice-PCMCIA-FEF2
  607. +%String6%=freekey2.install,PCMCIA\DECTDataDevice-PCMCIA_F22-4BD3
  608. +%String6%=freekey2.install,PCMCIA\DECTDataDevice-PCMCIA_F22-BBD9
  609. +
  610. +#endif
  611. + PCMCIA_DEVICE_NULL
  612. +};
  613. +
  614. +MODULE_DEVICE_TABLE(pcmcia, com_on_air_ids);
  615. +
  616. +/* returns an index into com_on_air_ids[] */
  617. +static int get_card_id(const struct pcmcia_device *link)
  618. +{
  619. + u32 hash[4] = {};
  620. + unsigned int i;
  621. +
  622. + for (i = 0; i < 4; i++) {
  623. + if (link->prod_id[i] == NULL)
  624. + continue;
  625. + hash[i] = crc32(0, link->prod_id[i], strlen(link->prod_id[i]));
  626. + }
  627. +
  628. + for (i = 0; i < ARRAY_SIZE(com_on_air_ids) - 1; i++) {
  629. + if ((hash[0] == com_on_air_ids[i].prod_id_hash[0]) &&
  630. + (hash[1] == com_on_air_ids[i].prod_id_hash[1]) &&
  631. + (hash[2] == com_on_air_ids[i].prod_id_hash[2]) &&
  632. + (hash[3] == com_on_air_ids[i].prod_id_hash[3]))
  633. + return i;
  634. + }
  635. + return -1;
  636. +}
  637. +
  638. +static struct pcmcia_driver coa_driver = {
  639. + .owner = THIS_MODULE,
  640. + .name = KBUILD_MODNAME,
  641. + .probe = com_on_air_probe,
  642. + .remove = com_on_air_remove,
  643. + .suspend = com_on_air_suspend,
  644. + .resume = com_on_air_resume,
  645. + .id_table = com_on_air_ids,
  646. +};
  647. +
  648. +static int __init init_com_on_air_cs(void)
  649. +{
  650. + return pcmcia_register_driver(&coa_driver);
  651. +}
  652. +
  653. +static void __exit exit_com_on_air_cs(void)
  654. +{
  655. + pcmcia_unregister_driver(&coa_driver);
  656. +}
  657. +
  658. +module_init(init_com_on_air_cs);
  659. +module_exit(exit_com_on_air_cs);
  660. diff --git a/drivers/dect/coa/com_on_air_pci.c b/drivers/dect/coa/com_on_air_pci.c
  661. new file mode 100644
  662. index 0000000..08c6e6f
  663. --- /dev/null
  664. +++ b/drivers/dect/coa/com_on_air_pci.c
  665. @@ -0,0 +1,165 @@
  666. +/*
  667. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  668. + *
  669. + * This program is free software; you can redistribute it and/or modify
  670. + * it under the terms of the GNU General Public License version 2 as
  671. + * published by the Free Software Foundation.
  672. + */
  673. +
  674. +#include <linux/kernel.h>
  675. +#include <linux/module.h>
  676. +#include <linux/init.h>
  677. +#include <linux/interrupt.h>
  678. +#include <linux/pci.h>
  679. +#include <net/dect/transceiver.h>
  680. +
  681. +#include "com_on_air.h"
  682. +
  683. +#define PCI_VENDOR_ID_QUICKLOGIC 0x11e3
  684. +#define PCI_DEVICE_ID_COA 0x0001
  685. +#define DEFINE_PCI_DEVICE_TABLE(_table) const struct pci_device_id _table[]
  686. +
  687. +static int coa_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
  688. +{
  689. + struct dect_transceiver *trx;
  690. + struct coa_device *dev;
  691. + void __iomem *base;
  692. + int err;
  693. +
  694. + err = pci_enable_device(pdev);
  695. + if (err < 0) {
  696. + dev_err(&pdev->dev, "failed to enable PCI device\n");
  697. + goto err1;
  698. + }
  699. + pci_set_master(pdev);
  700. +
  701. + err = pci_request_regions(pdev, KBUILD_MODNAME);
  702. + if (err < 0) {
  703. + dev_err(&pdev->dev, "failed to obtain PCI resources\n");
  704. + goto err2;
  705. + }
  706. +
  707. + base = ioremap_nocache(pci_resource_start(pdev, 0),
  708. + pci_resource_len(pdev, 0));
  709. + if (base == NULL) {
  710. + dev_err(&pdev->dev, "failed to remap PCI resource\n");
  711. + err = -EIO;
  712. + goto err3;
  713. + }
  714. +
  715. + trx = dect_transceiver_alloc(&sc1442x_transceiver_ops, sizeof(*dev));
  716. + if (trx == NULL) {
  717. + err = -ENOMEM;
  718. + goto err4;
  719. + }
  720. + pci_set_drvdata(pdev, trx);
  721. +
  722. + dev = dect_transceiver_priv(trx);
  723. + dev->type = COA_TYPE_PCI;
  724. + dev->dev = &pdev->dev;
  725. + dev->sc1442x_base = base;
  726. + dev->radio_ops = &coa_u2785_radio_ops;
  727. + dev->data_base = 0x0a00;
  728. + dev->data_mask = 0x7ff;
  729. + dev->cfg_reg = 0x1fe2;
  730. + dev->code_base = 0x1a00;
  731. +
  732. + err = sc1442x_init_device(dev);
  733. + if (err < 0) {
  734. + dev_err(&pdev->dev, "failed to initialize chip\n");
  735. + goto err5;
  736. + }
  737. +
  738. + err = request_irq(pdev->irq, sc1442x_interrupt, IRQF_SHARED,
  739. + KBUILD_MODNAME, trx);
  740. + if (err < 0) {
  741. + dev_err(&pdev->dev, "failed to request IRQ%d\n", pdev->irq);
  742. + goto err6;
  743. + }
  744. +
  745. + dev->irq = pdev->irq;
  746. + err = dect_register_transceiver(trx);
  747. + if (err < 0)
  748. + goto err7;
  749. +
  750. + return 0;
  751. +
  752. +err7:
  753. + free_irq(pdev->irq, trx);
  754. +err6:
  755. + sc1442x_shutdown_device(dev);
  756. +err5:
  757. + dect_transceiver_free(trx);
  758. +err4:
  759. + iounmap(base);
  760. +err3:
  761. + pci_release_regions(pdev);
  762. +err2:
  763. + pci_disable_device(pdev);
  764. +err1:
  765. + return err;
  766. +}
  767. +
  768. +static void coa_remove(struct pci_dev *pdev)
  769. +{
  770. + struct dect_transceiver *trx = pci_get_drvdata(pdev);
  771. + struct coa_device *dev = dect_transceiver_priv(trx);
  772. + u8 __iomem *sc1442x_base = dev->sc1442x_base;
  773. +
  774. + sc1442x_shutdown_device(dev);
  775. + free_irq(pdev->irq, trx);
  776. + dect_unregister_transceiver(trx);
  777. + iounmap(sc1442x_base);
  778. + pci_release_regions(pdev);
  779. + pci_disable_device(pdev);
  780. +}
  781. +
  782. +static int coa_suspend(struct pci_dev *pdev, pm_message_t state)
  783. +{
  784. + struct dect_transceiver *trx = pci_get_drvdata(pdev);
  785. + struct coa_device *dev = dect_transceiver_priv(trx);
  786. +
  787. + sc1442x_shutdown_device(dev);
  788. + pci_save_state(pdev);
  789. + return 0;
  790. +}
  791. +
  792. +static int coa_resume(struct pci_dev *pdev)
  793. +{
  794. + struct dect_transceiver *trx = pci_get_drvdata(pdev);
  795. + struct coa_device *dev = dect_transceiver_priv(trx);
  796. +
  797. + pci_restore_state(pdev);
  798. + return sc1442x_init_device(dev);
  799. +}
  800. +
  801. +static DEFINE_PCI_DEVICE_TABLE(coa_pci_tbl) = {
  802. + {PCI_DEVICE(PCI_VENDOR_ID_QUICKLOGIC, PCI_DEVICE_ID_COA)},
  803. + {}
  804. +};
  805. +
  806. +static struct pci_driver coa_driver = {
  807. + .name = KBUILD_MODNAME,
  808. + .id_table = coa_pci_tbl,
  809. + .probe = coa_probe,
  810. + .remove = coa_remove,
  811. + .suspend = coa_suspend,
  812. + .resume = coa_resume,
  813. +};
  814. +
  815. +static int __init coa_pci_init(void)
  816. +{
  817. + return pci_register_driver(&coa_driver);
  818. +}
  819. +
  820. +static void __exit coa_pci_exit(void)
  821. +{
  822. + pci_unregister_driver(&coa_driver);
  823. +}
  824. +
  825. +module_init(coa_pci_init);
  826. +module_exit(coa_pci_exit);
  827. +
  828. +MODULE_DESCRIPTION("Dosch&Amand COM-ON-AIR PCI driver");
  829. +MODULE_LICENSE("GPL");
  830. +MODULE_DEVICE_TABLE(pci, coa_pci_tbl);
  831. diff --git a/drivers/dect/coa/dip_opcodes.h b/drivers/dect/coa/dip_opcodes.h
  832. new file mode 100644
  833. index 0000000..bd50056
  834. --- /dev/null
  835. +++ b/drivers/dect/coa/dip_opcodes.h
  836. @@ -0,0 +1,157 @@
  837. +/*
  838. + * com_on_air - basic driver for the Dosch and Amand "com on air" cards
  839. + *
  840. + * This program is free software; you can redistribute it and/or modify
  841. + * it under the terms of the GNU General Public License version 2 as
  842. + * published by the Free Software Foundation.
  843. + *
  844. + * authors:
  845. + * (C) 2008 Andreas Schuler <krater at badterrorist dot com>
  846. + * (C) 2008 Matthias Wenzel <dect at mazzoo dot de>
  847. + *
  848. + */
  849. +
  850. +#ifndef DIP_OPCODE_H
  851. +#define DIP_OPCODE_H
  852. +
  853. +#define BR 0x01
  854. +#define JMP 0x02
  855. +#define JMP1 0x03
  856. +#define RTN 0x04
  857. +#define BK_A1 0x05
  858. +#define WNTM1 0x06
  859. +#define WNTP1 0x07
  860. +#define WNT 0x08
  861. +#define WT 0x09
  862. +#define RFDIS 0x0a
  863. +#define RFEN 0x0b
  864. +#define LD_PTR 0x0c
  865. +#define SLOTZERO 0x0d
  866. +#define BK_A 0x0e
  867. +#define BK_C 0x0f
  868. +
  869. +
  870. +#define B_RST 0x20
  871. +#define B_ST2 0x21
  872. +#define B_XT 0x24
  873. +#define B_BT2 0x25
  874. +#define B_BTFU 0x25
  875. +#define B_XOFF 0x26
  876. +#define B_ON 0x27
  877. +#define B_XON 0x27
  878. +#define UNLCK 0x28
  879. +#define B_SR 0x29
  880. +#define B_XR 0x2b
  881. +#define EN_SL_ADJ 0x2c
  882. +#define B_BR2 0x2d
  883. +#define B_BRFU 0x2d
  884. +#define B_RINV 0x2e
  885. +#define B_RON 0x2f
  886. +
  887. +
  888. +#define B_ST 0x31
  889. +#define B_TX 0x31
  890. +#define B_AT 0x32
  891. +#define B_RC 0x33
  892. +#define B_BT 0x34
  893. +#define B_BTFP 0x35
  894. +#define B_BTP 0x35
  895. +#define B_AT2 0x37
  896. +#define B_WRS 0x39
  897. +#define B_AR 0x3a
  898. +#define B_BR 0x3c
  899. +#define B_BRP 0x3d
  900. +#define B_BRFP 0x3d
  901. +#define B_AR2 0x3f
  902. +
  903. +
  904. +#define D_RST 0x40
  905. +#define D_ON 0x42
  906. +#define D_OFF 0x43
  907. +#define D_PREP 0x44
  908. +#define WSC 0x48
  909. +
  910. +
  911. +#define D_LDK 0x50
  912. +#define D_LDS 0x57
  913. +#define D_WRS 0x5f
  914. +
  915. +
  916. +#define U_PSC 0x60
  917. +#define U_INT0 0x61
  918. +#define RCK_INT 0x62
  919. +#define RCK_EXT 0x63
  920. +#define B_WB_OFF 0x64
  921. +#define B_WB_ON 0x65
  922. +#define CLK1 0x66
  923. +#define CLK3 0x67
  924. +#define U_CK8 0x68
  925. +#define U_CK4 0x69
  926. +#define U_CK2 0x6a
  927. +#define U_INT1 0x6b
  928. +#define U_CK1 0x6c
  929. +#define U_INT2 0x6d
  930. +#define U_INT3 0x6f
  931. +
  932. +
  933. +#define A_RCV0 0x80
  934. +#define A_RCV36 0x82
  935. +#define A_RCV30 0x83
  936. +#define A_RCV24 0x84
  937. +#define A_RCV18 0x85
  938. +#define A_RCV12 0x86
  939. +#define A_RCV6 0x87
  940. +#define A_RCV33 0x8a
  941. +#define A_RCV27 0x8b
  942. +#define A_RCV21 0x8c
  943. +#define A_RCV15 0x8d
  944. +#define A_RCV9 0x8e
  945. +#define A_RCV3 0x8f
  946. +
  947. +
  948. +#define MEN3N 0xa2
  949. +#define MEN3 0xa3
  950. +#define MEN1N 0xa4
  951. +#define MEN1 0xa5
  952. +#define MEN2N 0xa6
  953. +#define MEN2 0xa7
  954. +#define M_RD 0xa8
  955. +#define M_RST 0xa9
  956. +
  957. +
  958. +#define M_WRS 0xb8
  959. +#define M_WR 0xb9
  960. +
  961. +
  962. +#define A_RST 0xc0
  963. +#define A_MUTE 0xc1
  964. +#define A_STOFF 0xc2
  965. +#define A_ALAW 0xc3
  966. +#define A_DT 0xc4
  967. +#define A_NORM 0xc5
  968. +#define A_LDR 0xc6
  969. +#define A_LDW 0xc7
  970. +#define A_LIN 0xc8
  971. +#define A_MTOFF 0xc9
  972. +#define A_MUTE1 0xca
  973. +#define A_MTOFF1 0xcb
  974. +#define A_STON 0xcc
  975. +#define A_DT1 0xcd
  976. +#define A_LDR1 0xce
  977. +#define A_LDW1 0xcf
  978. +
  979. +
  980. +#define A_STRN 0xe0
  981. +#define P_LD 0xe8
  982. +#define P_EN 0xe9
  983. +#define P_SC 0xea
  984. +#define A_RST1 0xeb
  985. +#define P_LDL 0xec
  986. +#define P_LDH 0xed
  987. +#define C_ON 0xee
  988. +#define C_OFF 0xef
  989. +
  990. +
  991. +#define C_LD 0xfa
  992. +
  993. +#endif
  994. diff --git a/drivers/dect/coa/radio_lmx3161.c b/drivers/dect/coa/radio_lmx3161.c
  995. new file mode 100644
  996. index 0000000..9f6d5ae
  997. --- /dev/null
  998. +++ b/drivers/dect/coa/radio_lmx3161.c
  999. @@ -0,0 +1,84 @@
  1000. +/*
  1001. + * radio_lmx3161 - NSC LMX3161 Single Chip Radio Transceiver radio operations
  1002. + *
  1003. + * This program is free software; you can redistribute it and/or modify
  1004. + * it under the terms of the GNU General Public License version 2 as
  1005. + * published by the Free Software Foundation.
  1006. + *
  1007. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  1008. + */
  1009. +
  1010. +#include <linux/kernel.h>
  1011. +#include <linux/module.h>
  1012. +#include <linux/dect.h>
  1013. +#include <net/dect/dect.h>
  1014. +#include <net/dect/transceiver.h>
  1015. +
  1016. +#include "com_on_air.h"
  1017. +
  1018. +/* Intermediate frequency */
  1019. +#define RADIO_LMX3161_FREQ_IF 110592 /* kHz */
  1020. +
  1021. +/*
  1022. + * Control Bits
  1023. + */
  1024. +
  1025. +/* N-counter */
  1026. +#define RADIO_LMX3161_CTRL_N 0x0
  1027. +/* R-counter */
  1028. +#define RADIO_LMX3161_CTRL_R 0x2
  1029. +/* F-latch */
  1030. +#define RADIO_LMX3161_CTRL_F 0x1
  1031. +
  1032. +/*
  1033. + * Function Register (18 bit F-latch)
  1034. + */
  1035. +
  1036. +/* Prescaler modules select */
  1037. +#define RADIO_LMX3161_PRESCALER_32_33
  1038. +#define RADIO_LMX3161_PRESCALER_64_65
  1039. +/* Phase detector polarity: 0 = negative, 1 = positive */
  1040. +#define RADIO_LMX3161_PD (1 << 3)
  1041. +/* Charge pump current gain select: 0 = LOW (1*I_cpo), 1 = high (4*I_cpo) */
  1042. +#define RADIO_LMX3161_CP (1 << 4)
  1043. +/* tri-state charge pump output: 0 = normal, 1 = tri-state */
  1044. +#define RADIO_LMX3161_CP_TRISTATE (1 << 5)
  1045. +/* Receive chain power down control: 0 = power up, 1 = power down */
  1046. +#define RADIO_LMX3161_RX_POWER (1 << 7)
  1047. +/* Transmit chain power down control: 0 = power up, 1 = power down */
  1048. +#define RADIO_LMX3161_TX_POWER (1 << 8)
  1049. +/* Out 0 CMOS output: 0 = low, 1 = high */
  1050. +#define RADIO_LMX3161_CMOS0A (1 << 9)
  1051. +/* Out 1 CMOS output: 0 = low, 1 = high */
  1052. +#define RADIO_LMX3161_CMOS1 (1 << 10)
  1053. +/* Out 2 CMOS output: 0 = low, 1 = high */
  1054. +#define RADIO_LMX3161_CMOS2 (1 << 11)
  1055. +/* Power down mode select: */
  1056. +#define RADIO_LMX3161_POWER_DOWN_MASK (0x3 << 12)
  1057. +#define RADIO_LMX3161_POWER_DOWN_SW 0
  1058. +#define RADIO_LMX3161_POWER_DOWN_HARDWIRE (0x3 << 12)
  1059. +/* Demodulator gain select */
  1060. +/* Demodulator DC level shifting polarity */
  1061. +/* Demodulator DC level shift */
  1062. +
  1063. +static u64 lmx3161_map_band(struct coa_device *dev, const struct dect_band *band)
  1064. +{
  1065. + struct coa_freq_map_entry *fe;
  1066. + u32 frequency;
  1067. + u8 carrier;
  1068. +
  1069. + for (carrier = 0; carrier < band->carriers; carrier++) {
  1070. + frequency = band->frequency[carrier];
  1071. + fe = &dev->freq_map.carrier[carrier];
  1072. + }
  1073. + return 0;
  1074. +}
  1075. +
  1076. +const struct coa_radio_ops coa_lmx3161_radio_ops = {
  1077. + .type = "LMX3161",
  1078. + .rx_init = NULL,
  1079. + .tx_init = NULL,
  1080. + .set_carrier = NULL,
  1081. + .map_band = lmx3161_map_band,
  1082. +};
  1083. +EXPORT_SYMBOL_GPL(coa_lmx3161_radio_ops);
  1084. diff --git a/drivers/dect/coa/radio_u2785.c b/drivers/dect/coa/radio_u2785.c
  1085. new file mode 100644
  1086. index 0000000..dab53a0
  1087. --- /dev/null
  1088. +++ b/drivers/dect/coa/radio_u2785.c
  1089. @@ -0,0 +1,261 @@
  1090. +/*
  1091. + * radio_u2785 - ATMEL U2785 RF IC radio operations
  1092. + *
  1093. + * This program is free software; you can redistribute it and/or modify
  1094. + * it under the terms of the GNU General Public License version 2 as
  1095. + * published by the Free Software Foundation.
  1096. + *
  1097. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  1098. + */
  1099. +
  1100. +//#define DEBUG
  1101. +#include <linux/kernel.h>
  1102. +#include <linux/module.h>
  1103. +#include <linux/dect.h>
  1104. +#include <net/dect/dect.h>
  1105. +#include <net/dect/transceiver.h>
  1106. +
  1107. +#include "com_on_air.h"
  1108. +
  1109. +#define u2785_debug(dev, fmt, args...) \
  1110. + dev_dbg(dev->dev, "u2785: " fmt, ## args)
  1111. +
  1112. +/* Intermediate frequencies */
  1113. +#define RADIO_U2785_FREQ_IF1 110592 /* kHz */
  1114. +#define RADIO_U2785_FREQ_IF2 112320 /* kHz */
  1115. +
  1116. +/*
  1117. + * RC (Reference Divider)
  1118. + */
  1119. +#define RADIO_U2785_RC_SHIFT 22
  1120. +#define RADIO_U2785_RC_12 (0x1 << RADIO_U2785_RC_SHIFT)
  1121. +#define RADIO_U2785_RC_16 (0x2 << RADIO_U2785_RC_SHIFT)
  1122. +#define RADIO_U2785_RC_24 (0x3 << RADIO_U2785_RC_SHIFT)
  1123. +
  1124. +/*
  1125. + * SC (Swallow Counter) 0-31
  1126. + */
  1127. +#define RADIO_U2785_SC_SHIFT 17
  1128. +#define RADIO_U2785_SC_MAX 31
  1129. +#define RADIO_U2785_SC_MASK (0x1F << RADIO_U2785_SC_SHIFT)
  1130. +
  1131. +/*
  1132. + * MC (Main Divider)
  1133. + */
  1134. +#define RADIO_U2785_MC_SHIFT 15
  1135. +#define RADIO_U2785_MC_MIN 31
  1136. +#define RADIO_U2785_MC_MAX 34
  1137. +#define RADIO_U2785_MC_31 (0x0 << RADIO_U2785_MC_SHIFT)
  1138. +#define RADIO_U2785_MC_32 (0x1 << RADIO_U2785_MC_SHIFT)
  1139. +#define RADIO_U2785_MC_33 (0x2 << RADIO_U2785_MC_SHIFT)
  1140. +#define RADIO_U2785_MC_34 (0x3 << RADIO_U2785_MC_SHIFT)
  1141. +
  1142. +/*
  1143. + * PS (Phase Settings)
  1144. + */
  1145. +
  1146. +/* Phase of GF_DATA */
  1147. +#define RADIO_U2785_PS_GF (0x1 << 14)
  1148. +/* Phase of MCC Internal Connection */
  1149. +#define RADIO_U2785_PS_MCC (0x1 << 13)
  1150. +/* Phase of Charge Pump */
  1151. +#define RADIO_U2785_PS_CP (0x1 << 12)
  1152. +
  1153. +/*
  1154. + * Current-Saving Power-up/down Settings
  1155. + */
  1156. +
  1157. +/* Gaussian Filter */
  1158. +#define RADIO_U2785_GF (0x1 << 11)
  1159. +/* Modulation Compensation Circuit */
  1160. +#define RADIO_U2785_MCC (0x1 << 10)
  1161. +/* Frequency Doubler */
  1162. +#define RADIO_U2785_FD (0x1 << 8)
  1163. +/* OP1 + OP2 (Op Amps) */
  1164. +#define RADIO_U2785_OP (0x1 << 7)
  1165. +
  1166. +/*
  1167. + * Current Gain Settings (in percent)
  1168. + */
  1169. +#define RADIO_U2785_CGS_60 0x0
  1170. +#define RADIO_U2785_CGS_70 0x1
  1171. +#define RADIO_U2785_CGS_80 0x2
  1172. +#define RADIO_U2785_CGS_90 0x3
  1173. +#define RADIO_U2785_CGS_100 0x4
  1174. +#define RADIO_U2785_CGS_110 0x5
  1175. +#define RADIO_U2785_CGS_120 0x6
  1176. +#define RADIO_U2785_CGS_130 0x7
  1177. +
  1178. +/* GFCS (Gaussian-Filter Current Settings) */
  1179. +#define RADIO_U2785_GFCS_SHIFT 7
  1180. +/* CPCS (Charge-Pump Current Settings) */
  1181. +#define RADIO_U2785_CPCS_SHIFT 1
  1182. +/* MCCS (Modulation-Compensation Current Settings) */
  1183. +#define RADIO_U2785_MCCS_SHIFT 4
  1184. +
  1185. +/*
  1186. + * Pretune DAC Voltage
  1187. + */
  1188. +#define RADIO_U2785_DAC_SHIFT 4
  1189. +#define RADIO_U2785_DAC_300mV (0x0 << RADIO_U2785_DAC_SHIFT)
  1190. +#define RADIO_U2785_DAC_600mV (0x1 << RADIO_U2785_DAC_SHIFT)
  1191. +#define RADIO_U2785_DAC_900mV (0x2 << RADIO_U2785_DAC_SHIFT)
  1192. +#define RADIO_U2785_DAC_1200mV (0x3 << RADIO_U2785_DAC_SHIFT)
  1193. +#define RADIO_U2785_DAC_1400mV (0x4 << RADIO_U2785_DAC_SHIFT)
  1194. +#define RADIO_U2785_DAC_1700mV (0x5 << RADIO_U2785_DAC_SHIFT)
  1195. +#define RADIO_U2785_DAC_2000mV (0x6 << RADIO_U2785_DAC_SHIFT)
  1196. +#define RADIO_U2785_DAC_2300mV (0x7 << RADIO_U2785_DAC_SHIFT)
  1197. +
  1198. +/*
  1199. + * Address bit
  1200. + */
  1201. +#define RADIO_U2785_ADDRESS_BIT 0x1
  1202. +
  1203. +static void u2785_write_config(const struct coa_device *dev, u16 offset,
  1204. + u32 init1, u32 init2)
  1205. +{
  1206. + u8 init[5] = {
  1207. + /* first word: 24 bits */
  1208. + [0] = init1 >> 16,
  1209. + [1] = init1 >> 8,
  1210. + [2] = init1 | RADIO_U2785_ADDRESS_BIT,
  1211. + /* second word: 9 bits */
  1212. + [3] = init2 >> 1,
  1213. + [4] = 0,
  1214. + };
  1215. +
  1216. + sc1442x_rfdesc_write(dev, offset, init, sizeof(init));
  1217. +}
  1218. +
  1219. +static void u2785_rx_init(const struct coa_device *dev, u16 offset)
  1220. +{
  1221. + u32 init1 = 0, init2 = 0;
  1222. +
  1223. + init1 |= RADIO_U2785_RC_12;
  1224. + init1 |= RADIO_U2785_MC_32;
  1225. + init1 |= 10 << RADIO_U2785_SC_SHIFT;
  1226. +
  1227. + init1 |= RADIO_U2785_CGS_100 << RADIO_U2785_CPCS_SHIFT;
  1228. +
  1229. + init2 |= RADIO_U2785_FD;
  1230. + init2 |= RADIO_U2785_CGS_100 << RADIO_U2785_MCCS_SHIFT;
  1231. +
  1232. + u2785_write_config(dev, offset, init1, init2);
  1233. +}
  1234. +
  1235. +static void u2785_tx_init(const struct coa_device *dev, u16 offset)
  1236. +{
  1237. + u32 init1 = 0, init2 = 0;
  1238. +
  1239. + init1 |= RADIO_U2785_RC_12;
  1240. + init1 |= RADIO_U2785_MC_34;
  1241. + init1 |= 7 << RADIO_U2785_SC_SHIFT;
  1242. +
  1243. + init1 |= RADIO_U2785_GF;
  1244. + init1 |= RADIO_U2785_MCC;
  1245. + init1 |= RADIO_U2785_CGS_120 << RADIO_U2785_GFCS_SHIFT;
  1246. + init1 |= RADIO_U2785_DAC_1400mV;
  1247. + init1 |= RADIO_U2785_CGS_60 << RADIO_U2785_CPCS_SHIFT;
  1248. +
  1249. + init2 |= RADIO_U2785_FD;
  1250. + init2 |= RADIO_U2785_CGS_130 << RADIO_U2785_MCCS_SHIFT;
  1251. +
  1252. + u2785_write_config(dev, offset, init1, init2);
  1253. +}
  1254. +
  1255. +static void u2785_write_carrier(const struct coa_device *dev, u16 offset,
  1256. + u32 init1)
  1257. +{
  1258. + u8 init[3] = {
  1259. + /* first word: 24 bits */
  1260. + [0] = init1 >> 16,
  1261. + [1] = init1 >> 8,
  1262. + [2] = init1 | RADIO_U2785_ADDRESS_BIT,
  1263. + };
  1264. +
  1265. + sc1442x_rfdesc_write(dev, offset, init, sizeof(init));
  1266. +}
  1267. +
  1268. +static void u2785_set_carrier(const struct coa_device *dev, u16 offset,
  1269. + enum dect_slot_states mode, u8 carrier)
  1270. +{
  1271. + const struct coa_freq_map_entry *fe = &dev->freq_map.carrier[carrier];
  1272. + u32 init1 = 0;
  1273. +
  1274. + init1 |= RADIO_U2785_RC_12;
  1275. +
  1276. + switch (mode) {
  1277. + case DECT_SLOT_SCANNING:
  1278. + case DECT_SLOT_RX:
  1279. + init1 |= (fe->rx.divisor - RADIO_U2785_MC_MIN) <<
  1280. + RADIO_U2785_MC_SHIFT;
  1281. + init1 |= fe->rx.swcnt << RADIO_U2785_SC_SHIFT;
  1282. +
  1283. + init1 |= RADIO_U2785_CGS_100 << RADIO_U2785_CPCS_SHIFT;
  1284. + break;
  1285. + case DECT_SLOT_TX:
  1286. + init1 |= (fe->tx.divisor - RADIO_U2785_MC_MIN) <<
  1287. + RADIO_U2785_MC_SHIFT;
  1288. + init1 |= fe->tx.swcnt << RADIO_U2785_SC_SHIFT;
  1289. +
  1290. + init1 |= RADIO_U2785_GF;
  1291. + init1 |= RADIO_U2785_MCC;
  1292. + init1 |= RADIO_U2785_CGS_120 << RADIO_U2785_GFCS_SHIFT;
  1293. + init1 |= RADIO_U2785_DAC_1400mV;
  1294. + init1 |= RADIO_U2785_CGS_60 << RADIO_U2785_CPCS_SHIFT;
  1295. + break;
  1296. + default:
  1297. + return;
  1298. + }
  1299. +
  1300. + u2785_write_carrier(dev, offset, init1);
  1301. +}
  1302. +
  1303. +static int u2785_map_freq(u32 frequency, u8 *s_mc, u8 *s_sc)
  1304. +{
  1305. + frequency /= DECT_CARRIER_WIDTH;
  1306. +
  1307. + *s_mc = frequency / 32;
  1308. + if (*s_mc < RADIO_U2785_MC_MIN || *s_mc > RADIO_U2785_MC_MAX)
  1309. + return false;
  1310. + *s_sc = frequency % 32;
  1311. + return true;
  1312. +}
  1313. +
  1314. +static u64 u2785_map_band(struct coa_device *dev, const struct dect_band *band)
  1315. +{
  1316. + struct coa_freq_map_entry *fe;
  1317. + u64 carriers = 0;
  1318. + u32 frequency;
  1319. + u8 carrier;
  1320. +
  1321. + for (carrier = 0; carrier < band->carriers; carrier++) {
  1322. + frequency = band->frequency[carrier];
  1323. + fe = &dev->freq_map.carrier[carrier];
  1324. +
  1325. + if (!u2785_map_freq(frequency - RADIO_U2785_FREQ_IF1,
  1326. + &fe->rx.divisor, &fe->rx.swcnt))
  1327. + continue;
  1328. + if (!u2785_map_freq(frequency,
  1329. + &fe->tx.divisor, &fe->tx.swcnt))
  1330. + continue;
  1331. +
  1332. + carriers |= 1 << carrier;
  1333. + u2785_debug(dev, "carrier %u (%u.%03uMHz) => "
  1334. + "rx: div: %u sw: %u tx: div: %u sw: %u\n",
  1335. + carrier, frequency / 1000, frequency % 1000,
  1336. + fe->rx.divisor, fe->rx.swcnt,
  1337. + fe->tx.divisor, fe->tx.swcnt);
  1338. + }
  1339. +
  1340. + return carriers;
  1341. +}
  1342. +
  1343. +const struct coa_radio_ops coa_u2785_radio_ops = {
  1344. + .type = "U2785B",
  1345. + .rx_init = u2785_rx_init,
  1346. + .tx_init = u2785_tx_init,
  1347. + .set_carrier = u2785_set_carrier,
  1348. + .map_band = u2785_map_band,
  1349. +};
  1350. +EXPORT_SYMBOL_GPL(coa_u2785_radio_ops);
  1351. diff --git a/drivers/dect/coa/sc1442x.c b/drivers/dect/coa/sc1442x.c
  1352. new file mode 100644
  1353. index 0000000..73b9869
  1354. --- /dev/null
  1355. +++ b/drivers/dect/coa/sc1442x.c
  1356. @@ -0,0 +1,1032 @@
  1357. +/*
  1358. + * com_on_air - basic driver for the Dosch and Amand "com on air" cards
  1359. + *
  1360. + * This program is free software; you can redistribute it and/or modify
  1361. + * it under the terms of the GNU General Public License version 2 as
  1362. + * published by the Free Software Foundation.
  1363. + *
  1364. + * authors:
  1365. + * (C) 2008 Andreas Schuler <krater at badterrorist dot com>
  1366. + * (C) 2008 Matthias Wenzel <dect at mazzoo dot de>
  1367. + * (C) 2009 Patrick McHardy <[email protected]>
  1368. + *
  1369. + */
  1370. +
  1371. +#include <linux/kernel.h>
  1372. +#include <linux/module.h>
  1373. +#include <linux/skbuff.h>
  1374. +#include <linux/dect.h>
  1375. +#include <net/dect/dect.h>
  1376. +#include <net/dect/mac_csf.h>
  1377. +#include <net/dect/dsc.h>
  1378. +#include <net/dect/transceiver.h>
  1379. +#include <asm/io.h>
  1380. +
  1381. +#include "com_on_air.h"
  1382. +#include "sc1442x_firmware.h"
  1383. +#include "dip_opcodes.h"
  1384. +
  1385. +/*
  1386. + * The sc1442x contain a 2k data RAM and 512b code RAM. The two primary
  1387. + * methods for memory access are direct and indirect access. In indirect
  1388. + * mode, the access goes through the DIP and the memory bank needs to be
  1389. + * mapped by writting its number to the control register. In direct mode
  1390. + * the memory can be accessed directly, the three modes differ only in
  1391. + * the address space layout. The choice between direct and indirect mode
  1392. + * is made by the device vendor.
  1393. + *
  1394. + * The address space is layed out as follows:
  1395. + *
  1396. + * PCI - size 8k:
  1397. + *
  1398. + * 0x0a00 - 0x11ff: data memory
  1399. + * 0x1a00 - 0x1bff: code memory
  1400. + * 0x1f00 - 0x1fff: DIP control and status registers
  1401. + *
  1402. + * PCMCIA - size 1k:
  1403. + *
  1404. + * 0x0000 - 0x01ff: 256 bytes memory
  1405. + * 0x0200 - 0x02ff: DIP control and status registers
  1406. + *
  1407. + * Memory of the PCMCIA device is addressed in 16 bit little endian quantities.
  1408. + *
  1409. + * The first bank of the data memory contains DIP specific control data,
  1410. + * the remaining banks are used to store packet and slot configuration data,
  1411. + * with each slot having one half memory bank assigned.
  1412. + *
  1413. + * The per slot data of 128 bytes is layed out as follows:
  1414. + *
  1415. + * Offset RX TX
  1416. + *
  1417. + * 0x00 - 0x05: Status Preamble
  1418. + * 0x06 - 0x0d: A-Field A-Field
  1419. + * 0x0e - 0x35: B-Field B-Field
  1420. + *
  1421. + * 0x65 - 0x68: Radio Cfg Radio Cfg
  1422. + * 0x69 - 0x6f: BMC Ctrl BMC Ctrl
  1423. + * 0x70 - 0x7f: DCS IV/Key DCS IV/Key
  1424. + * 0x70 - 0x7a: DCS state DCS state
  1425. + */
  1426. +
  1427. +#define SC1442X_DIPSTOPPED 0x80
  1428. +#define SC1442X_PRESCALER_ENABLED 0x40
  1429. +#define SC1442X_TIMER_INTERRUPT_ENABLED 0x02
  1430. +
  1431. +/* Memory access modes */
  1432. +#define SC1442X_LINEAR_MODE 0x01
  1433. +#define SC1442X_LINEAR_MODE_0 (SC14421_LINEAR_MODE | 0x0)
  1434. +#define SC1442X_LINEAR_MODE_1 (SC14421_LINEAR_MODE | 0x2)
  1435. +#define SC1442X_LINEAR_MODE_2 (SC14421_LINEAR_MODE | 0x3)
  1436. +
  1437. +/* Indirect mode RAM bank select */
  1438. +#define SC1442X_RAMBANK0 0x00
  1439. +#define SC1442X_RAMBANK1 0x04
  1440. +#define SC1442X_RAMBANK2 0x08
  1441. +#define SC1442X_RAMBANK3 0x0c
  1442. +#define SC1442X_RAMBANK4 0x10
  1443. +#define SC1442X_RAMBANK5 0x14
  1444. +#define SC1442X_RAMBANK6 0x18
  1445. +#define SC1442X_RAMBANK7 0x1c
  1446. +#define SC1442X_CODEBANK 0x20
  1447. +#define SC1442X_BANKSIZE 0x100
  1448. +
  1449. +/* Interrupts 0-3 */
  1450. +#define SC1442X_IRQ_SLOT_0_5 0x01
  1451. +#define SC1442X_IRQ_SLOT_6_11 0x02
  1452. +#define SC1442X_IRQ_SLOT_12_17 0x04
  1453. +#define SC1442X_IRQ_SLOT_18_23 0x08
  1454. +#define SC1442X_IRQ_TIMER 0x10
  1455. +#define SC1442X_IRQ_MASK 0x1f
  1456. +
  1457. +/* Interrupt status 1: DIP/CLK100/TIM1/TIM0/SPI/UART/P10/KEYB */
  1458. +#define SC14424_RESET_INT_PENDING_1 0x1f02
  1459. +/* Interrupt status 2: CLK8K/TONE */
  1460. +#define SC14424_RESET_INT_PENDING_2 0x1f03
  1461. +
  1462. +/* DIP_INT and CLK100_INT priority level */
  1463. +#define SC14424_INT_PRIORITY_1 0x1f06
  1464. +
  1465. +/* P1 output control */
  1466. +#define SC14424_P1_SET_OUTPUT_DATA 0x1f21
  1467. +#define SC14424_P1_RESET_OUTPUT_DATA 0x1f22
  1468. +
  1469. +/* P1 input/output direction */
  1470. +#define SC14424_P1_DIR_REG 0x1f23
  1471. +
  1472. +/*
  1473. + * Burst Mode Controller control information
  1474. + */
  1475. +
  1476. +/* Maximum number of unmasked errors in S-field bits 8 to 31 */
  1477. +#define SC1442X_BC0_S_ERR_SHIFT 4
  1478. +/* Invert incoming data (RDI) */
  1479. +#define SC1442X_BC0_INV_RDI 0x08
  1480. +/* Invert outgoing data (TDO) */
  1481. +#define SC1442X_BC0_INV_TDO 0x04
  1482. +/* Disable writing B-field on A-field CRC error */
  1483. +#define SC1442X_BC0_SENS_A 0x02
  1484. +/* PP/FP mode */
  1485. +#define SC1442X_BC0_PP_MODE 0x01
  1486. +
  1487. +/* Error test mask for S-field bits 15-8 */
  1488. +#define SC1442X_BC1_MASK_MASK 0xff
  1489. +
  1490. +/* Sliding error test mask for S-field bits 15-8 */
  1491. +#define SC1442X_BC2_SLIDE_MASK 0xff
  1492. +
  1493. +/* DAC output value when BCM is active (for frequency control?) */
  1494. +#define SC1442X_BC3_DAC_MASK 0x1f
  1495. +
  1496. +/* Only perform phase jump for correct A-field CRC + SL_EN_ADJ command */
  1497. +#define SC1442X_BC4_ADP 0x10
  1498. +/* Window in which S-field is accepted */
  1499. +#define SC1442X_BC4_WIN_MASK 0x0f
  1500. +
  1501. +/* Amplitude-trimming of gaussian shape */
  1502. +#define SC1442X_BC5_VOL_SHIFT 4
  1503. +/* Disable scrambling */
  1504. +#define SC1442X_BC5_SC_OFF 0x08
  1505. +/* PD1 synchronization pattern:
  1506. + * 0 = S-field received, 1 = preamble + first 2 bits of synchronization word */
  1507. +#define SC1442X_BC5_DO_FR 0x04
  1508. +/* TDO output shape */
  1509. +#define SC1442X_BC5_TDO_DIGITAL 0x00
  1510. +#define SC1442X_BC5_TDO_GAUSIAN 0x01
  1511. +#define SC1442X_BC5_TDO_POWER_DOWN 0x02
  1512. +#define SC1442X_BC5_TDO_MID_LEVEL 0x03
  1513. +
  1514. +/* Low 4 bits of multiframe number */
  1515. +#define SC1442X_BC6_MFR_SHIFT 4
  1516. +#define SC1442X_BC6_MFR_MASK 0xf0
  1517. +/* Frame number */
  1518. +#define SC1442X_BC6_FR_MASK 0x0f
  1519. +
  1520. +/*
  1521. + * Burst Mode Controller status information
  1522. + */
  1523. +
  1524. +/* Peak binary value of ADC (RSSI) */
  1525. +#define SC1442X_ST0_ADC_MASK 0x3f
  1526. +
  1527. +/* S-pattern recognized according to BMC configuration */
  1528. +#define SC1442X_ST1_IN_SYNC 0x80
  1529. +
  1530. +/* A-field R-CRC correct */
  1531. +#define SC1442X_ST1_A_CRC 0x40
  1532. +
  1533. +/* Protected Bn-subfield R-CRC correct */
  1534. +#define SC1442X_ST1_B_CRC_MASK 0x3c
  1535. +#define SC1442X_ST1_B1_CRC 0x20
  1536. +#define SC1442X_ST1_B2_CRC 0x10
  1537. +#define SC1442X_ST1_B3_CRC 0x08
  1538. +#define SC1442X_ST1_B4_CRC 0x04
  1539. +
  1540. +/* B-field X-CRC correct */
  1541. +#define SC1442X_ST1_X_CRC 0x02
  1542. +
  1543. +/* Z-field equals X-CRC */
  1544. +#define SC1442X_ST1_Z_CRC 0x01
  1545. +
  1546. +/* Phase offset of received S-field: which of the nine internal clock cycles
  1547. + * per symbol sampled the incoming data. The frequency deviation can be
  1548. + * calculated from the difference of the offsets of two consequitive frames as:
  1549. + *
  1550. + * K * (T / 9) / 10m = K * 96ns / 10m = K * 9.6ppm
  1551. + */
  1552. +#define SC1442X_ST2_TAP_SHIFT 4
  1553. +#define SC1442X_ST2_TAP_MASK 0xf0
  1554. +#define SC1442X_ST2_TAP_SCALE (DECT_PHASE_OFFSET_SCALE * 96 / 10)
  1555. +
  1556. +/* Number of unmasked S-field errors according to BMC configuration */
  1557. +#define SC1442X_ST2_S_ERR_SHIFT 0
  1558. +#define SC1442X_ST2_S_ERR_MASK 0x0f
  1559. +
  1560. +/* Phase offset of received S-field: difference of number of symbol periods
  1561. + * between nominal 11520 symbols per frame and actual number of symbols. The
  1562. + * frequency deviation can be calculated from the difference of two
  1563. + * consequitive frames as:
  1564. + *
  1565. + * N * T / 10m = N * 870ns / 10m = N * 87ppm
  1566. + */
  1567. +#define SC1442X_ST3_PHASE_MASK 0xff
  1568. +#define SC1442X_ST3_PHASE_SCALE (DECT_PHASE_OFFSET_SCALE * 87)
  1569. +
  1570. +/* DC offset of received data to comparator reference input (DAC) */
  1571. +#define SC1442X_ST4_DC_MASK 0x3f
  1572. +
  1573. +/*
  1574. + * Codec configuration
  1575. + */
  1576. +
  1577. +#define SC1442X_CC_SIZE 6
  1578. +
  1579. +#define SC1442X_CC0_STANDBY 0xc2
  1580. +#define SC1442X_CC0_POWERDOWN 0x3d
  1581. +
  1582. +/* Logical memory banks */
  1583. +#define SC1442X_BANK_UNITS 8
  1584. +#define SC1442X_SLOT_BANK_SIZE 128
  1585. +
  1586. +static const u8 banktable[] = {
  1587. + SC1442X_RAMBANK1,
  1588. + SC1442X_RAMBANK2,
  1589. + SC1442X_RAMBANK3,
  1590. + SC1442X_RAMBANK4,
  1591. + SC1442X_RAMBANK5,
  1592. + SC1442X_RAMBANK6,
  1593. +};
  1594. +
  1595. +static const u8 slottable[] = {
  1596. + Slot00, Slot01, Slot02, Slot03, Slot04, Slot05, Slot06, Slot07,
  1597. + Slot08, Slot09, Slot10, Slot11, Slot12, Slot13, Slot14, Slot15,
  1598. + Slot16, Slot17, Slot18, Slot19, Slot20, Slot21, Slot22, Slot23,
  1599. +};
  1600. +
  1601. +static const u8 sc1442x_rx_funcs[DECT_PACKET_MAX + 1][DECT_B_MAX + 1][2][2] = {
  1602. + [DECT_PACKET_P00][DECT_B_NONE][0][0] = RX_P00,
  1603. + [DECT_PACKET_P00][DECT_B_NONE][0][1] = RX_P00_Sync,
  1604. + [DECT_PACKET_P32][DECT_B_UNPROTECTED][0][0] = RX_P32U,
  1605. + [DECT_PACKET_P32][DECT_B_UNPROTECTED][1][0] = RX_P32U_Enc,
  1606. + [DECT_PACKET_P640j][DECT_B_UNPROTECTED][0][0] = RX_P640j,
  1607. + [DECT_PACKET_P640j][DECT_B_UNPROTECTED][1][0] = RX_P640j_Enc,
  1608. +};
  1609. +
  1610. +static const u8 sc1442x_tx_funcs[DECT_PACKET_MAX + 1][DECT_B_MAX + 1][2] = {
  1611. + [DECT_PACKET_P00][DECT_B_NONE][0] = TX_P00,
  1612. + [DECT_PACKET_P32][DECT_B_UNPROTECTED][0] = TX_P32U,
  1613. + [DECT_PACKET_P32][DECT_B_UNPROTECTED][1] = TX_P32U_Enc,
  1614. + [DECT_PACKET_P640j][DECT_B_UNPROTECTED][0] = TX_P640j,
  1615. + [DECT_PACKET_P640j][DECT_B_UNPROTECTED][1] = TX_P640j_Enc,
  1616. +};
  1617. +
  1618. +/*
  1619. + * Raw IO functions
  1620. + */
  1621. +
  1622. +static void sc1442x_lock_mem(struct coa_device *dev) __acquires(dev->lock)
  1623. +{
  1624. + spin_lock_irq(&dev->lock);
  1625. +}
  1626. +
  1627. +static void sc1442x_unlock_mem(struct coa_device *dev) __releases(dev->lock)
  1628. +{
  1629. + mmiowb();
  1630. + spin_unlock_irq(&dev->lock);
  1631. +}
  1632. +
  1633. +static u8 sc1442x_readb(const struct coa_device *dev, u16 offset)
  1634. +{
  1635. + switch (dev->type) {
  1636. + case COA_TYPE_PCI:
  1637. + return readb(dev->sc1442x_base + offset);
  1638. + case COA_TYPE_PCMCIA:
  1639. + return le16_to_cpu(readw(dev->sc1442x_base + 2 * offset));
  1640. + default:
  1641. + BUG();
  1642. + }
  1643. +}
  1644. +
  1645. +static u16 sc1442x_readw(const struct coa_device *dev, u16 offset)
  1646. +{
  1647. + u32 tmp;
  1648. +
  1649. + switch (dev->type) {
  1650. + case COA_TYPE_PCI:
  1651. + return le16_to_cpu(readw(dev->sc1442x_base + offset));
  1652. + case COA_TYPE_PCMCIA:
  1653. + tmp = le32_to_cpu(readl(dev->sc1442x_base + 2 * offset));
  1654. + return (tmp >> 8) | (tmp & 0xff);
  1655. + default:
  1656. + BUG();
  1657. + }
  1658. +}
  1659. +
  1660. +static void sc1442x_writeb(const struct coa_device *dev, u16 offset, u8 value)
  1661. +{
  1662. + switch (dev->type) {
  1663. + case COA_TYPE_PCI:
  1664. + writeb(value, dev->sc1442x_base + offset);
  1665. + break;
  1666. + case COA_TYPE_PCMCIA:
  1667. + writew(cpu_to_le16(value), dev->sc1442x_base + 2 * offset);
  1668. + break;
  1669. + }
  1670. +}
  1671. +
  1672. +static void sc1442x_writew(const struct coa_device *dev, u16 offset, u16 value)
  1673. +{
  1674. + u32 tmp;
  1675. +
  1676. + switch (dev->type) {
  1677. + case COA_TYPE_PCI:
  1678. + writew(cpu_to_le16(value), dev->sc1442x_base + offset);
  1679. + break;
  1680. + case COA_TYPE_PCMCIA:
  1681. + tmp = ((value & 0xff00) << 8) | (value & 0xff);
  1682. + writel(cpu_to_le32(tmp), dev->sc1442x_base + 2 * offset);
  1683. + break;
  1684. + }
  1685. +}
  1686. +
  1687. +static void sc1442x_stop_dip(struct coa_device *dev)
  1688. +{
  1689. + /* Prevent the interrupt handler from restarting the DIP */
  1690. + dev->ctrl = SC1442X_DIPSTOPPED;
  1691. +
  1692. + /* Stop the DIP and wait for interrupt handler to complete */
  1693. + sc1442x_writeb(dev, dev->cfg_reg, SC1442X_DIPSTOPPED);
  1694. + synchronize_irq(dev->irq);
  1695. +}
  1696. +
  1697. +static void sc1442x_start_dip(struct coa_device *dev)
  1698. +{
  1699. + dev->ctrl = 0;
  1700. + sc1442x_writeb(dev, dev->cfg_reg, 0x00);
  1701. +}
  1702. +
  1703. +static void sc1442x_switch_to_bank(const struct coa_device *dev, u8 bank)
  1704. +{
  1705. + if (dev->type != COA_TYPE_PCMCIA)
  1706. + return;
  1707. + sc1442x_writeb(dev, dev->cfg_reg, bank | dev->ctrl);
  1708. + /* need to wait for 4 IO cycles */
  1709. + inb_p(dev->config_base);
  1710. + inb_p(dev->config_base);
  1711. + inb_p(dev->config_base);
  1712. + inb_p(dev->config_base);
  1713. +}
  1714. +
  1715. +static void sc1442x_toggle_led(struct coa_device *dev)
  1716. +{
  1717. + if (dev->type != COA_TYPE_PCI)
  1718. + return;
  1719. +
  1720. + if ((dev->led & 0xf) > 0x7)
  1721. + sc1442x_writeb(dev, SC14424_P1_SET_OUTPUT_DATA, 0x40);
  1722. + else
  1723. + sc1442x_writeb(dev, SC14424_P1_RESET_OUTPUT_DATA, 0x40);
  1724. + dev->led++;
  1725. +}
  1726. +
  1727. +/*
  1728. + * Code memory IO functions
  1729. + */
  1730. +static void sc1442x_write_cmd(const struct coa_device *dev, u16 label,
  1731. + u8 opcode, u8 operand)
  1732. +{
  1733. + sc1442x_writew(dev, dev->code_base + 2 * label, operand << 8 | opcode);
  1734. +}
  1735. +
  1736. +static void sc1442x_to_cmem(const struct coa_device *dev,
  1737. + const u8 *src, u16 length)
  1738. +{
  1739. + u16 i;
  1740. +
  1741. + for (i = 0; i < length; i++)
  1742. + sc1442x_writeb(dev, dev->code_base + i, src[i]);
  1743. +}
  1744. +
  1745. +/*
  1746. + * Data memory IO functions
  1747. + */
  1748. +static inline u8 sc1442x_dreadb(const struct coa_device *dev, u16 offset)
  1749. +{
  1750. + return sc1442x_readb(dev, dev->data_base + (offset & dev->data_mask));
  1751. +}
  1752. +
  1753. +static inline u16 sc1442x_dreadw(const struct coa_device *dev, u16 offset)
  1754. +{
  1755. + return sc1442x_readw(dev, dev->data_base + (offset & dev->data_mask));
  1756. +}
  1757. +
  1758. +static inline void sc1442x_dwriteb(const struct coa_device *dev,
  1759. + u16 offset, u8 value)
  1760. +{
  1761. + sc1442x_writeb(dev, dev->data_base + (offset & dev->data_mask), value);
  1762. +}
  1763. +
  1764. +static inline void sc1442x_dwritew(const struct coa_device *dev,
  1765. + u16 offset, u16 value)
  1766. +{
  1767. + sc1442x_writew(dev, dev->data_base + (offset & dev->data_mask), value);
  1768. +}
  1769. +
  1770. +static void sc1442x_to_dmem(const struct coa_device *dev, u16 offset,
  1771. + const void *src, u16 length)
  1772. +{
  1773. + u16 i = 0;
  1774. +
  1775. + for (; length >= 2; length -= 2, i += 2)
  1776. + sc1442x_dwritew(dev, offset + i, *(u16 *)(src + i));
  1777. + for (; length >= 1; length -= 1, i += 1)
  1778. + sc1442x_dwriteb(dev, offset + i, *(u8 *)(src + i));
  1779. +}
  1780. +
  1781. +static void sc1442x_from_dmem(const struct coa_device *dev, void *dst,
  1782. + u16 offset, u16 length)
  1783. +{
  1784. + u16 i = 0;
  1785. +
  1786. + for (; length >= 2; length -= 2, i += 2)
  1787. + *(u16 *)(dst + i) = sc1442x_dreadw(dev, offset + i);
  1788. + for (; length >= 1; length -= 1, i += 1)
  1789. + *(u8 *)(dst + i) = sc1442x_dreadb(dev, offset + i);
  1790. +}
  1791. +
  1792. +static u8 sc1442x_dip_bankaddress(u8 slot)
  1793. +{
  1794. + return (slot / 2 + 2) * SC1442X_SLOT_BANK_SIZE / SC1442X_BANK_UNITS;
  1795. +}
  1796. +
  1797. +static u8 sc1442x_slot_bank(u8 slot)
  1798. +{
  1799. + return banktable[slot / 4];
  1800. +}
  1801. +
  1802. +static u16 sc1442x_slot_offset(u8 slot)
  1803. +{
  1804. + u16 offset;
  1805. +
  1806. + offset = SC1442X_BANKSIZE + slot / 4 * SC1442X_BANKSIZE;
  1807. + if (slot & 0x2)
  1808. + offset += SC1442X_BANKSIZE / 2;
  1809. + return offset;
  1810. +}
  1811. +
  1812. +void sc1442x_rfdesc_write(const struct coa_device *dev, u16 offset,
  1813. + const u8 *src, u16 length)
  1814. +{
  1815. + sc1442x_to_dmem(dev, offset + RF_DESC, src, length);
  1816. +}
  1817. +
  1818. +/*
  1819. + * Ciphering
  1820. + */
  1821. +
  1822. +static void sc1442x_dcs_init(const struct coa_device *dev,
  1823. + const struct dect_transceiver *trx,
  1824. + u8 slot, u32 mfn, u8 framenum)
  1825. +{
  1826. + const struct dect_transceiver_slot *ts = &trx->slots[slot];
  1827. + u16 off = sc1442x_slot_offset(slot);
  1828. + __le64 iv;
  1829. +
  1830. + iv = dect_dsc_iv(mfn, framenum);
  1831. + sc1442x_to_dmem(dev, off + DCS_IV, &iv, 8);
  1832. + sc1442x_to_dmem(dev, off + DCS_CK, &ts->ck, 8);
  1833. +}
  1834. +
  1835. +/* Transfer DCS cipher state between two TDD slots of a MAC connection */
  1836. +static void sc1442x_transfer_dcs_state(struct coa_device *dev,
  1837. + struct dect_transceiver *trx,
  1838. + u8 slot)
  1839. +{
  1840. + u8 slot2 = slot + DECT_HALF_FRAME_SIZE;
  1841. + struct dect_transceiver_slot *ts1 = &trx->slots[slot];
  1842. + struct dect_transceiver_slot *ts2 = &trx->slots[slot2];
  1843. + u8 dcs_state[DCS_STATE_SIZE];
  1844. + u16 off;
  1845. +
  1846. + if (!(ts1->flags & DECT_SLOT_CIPHER) ||
  1847. + !(ts2->flags & DECT_SLOT_CIPHER))
  1848. + return;
  1849. +
  1850. + sc1442x_switch_to_bank(dev, sc1442x_slot_bank(slot));
  1851. + off = sc1442x_slot_offset(slot);
  1852. + sc1442x_from_dmem(dev, dcs_state, off + DCS_STATE, DCS_STATE_SIZE);
  1853. +
  1854. + sc1442x_switch_to_bank(dev, sc1442x_slot_bank(slot2));
  1855. + off = sc1442x_slot_offset(slot2);
  1856. + sc1442x_to_dmem(dev, off + DCS_STATE, dcs_state, DCS_STATE_SIZE);
  1857. +}
  1858. +
  1859. +/*
  1860. + * Transceiver operations
  1861. + */
  1862. +
  1863. +static void sc1442x_disable(const struct dect_transceiver *trx)
  1864. +{
  1865. + sc1442x_stop_dip(dect_transceiver_priv(trx));
  1866. +}
  1867. +
  1868. +static void sc1442x_enable(const struct dect_transceiver *trx)
  1869. +{
  1870. + const struct coa_device *dev = dect_transceiver_priv(trx);
  1871. + u8 slot;
  1872. +
  1873. + /* Restore slot table to a pristine state */
  1874. + sc1442x_switch_to_bank(dev, SC1442X_CODEBANK);
  1875. + for (slot = 0; slot < DECT_FRAME_SIZE; slot++) {
  1876. + sc1442x_write_cmd(dev, slottable[slot] + 0, WT, 1);
  1877. + sc1442x_write_cmd(dev, slottable[slot] + 1, WNT, 1);
  1878. + }
  1879. +
  1880. + if (trx->cell->mode == DECT_MODE_FP) {
  1881. + sc1442x_write_cmd(dev, ClockSyncOn, WT, 1);
  1882. + sc1442x_write_cmd(dev, ClockAdjust, WT, 1);
  1883. + sc1442x_write_cmd(dev, ClockSyncOff, WT, 1);
  1884. +
  1885. + sc1442x_write_cmd(dev, TX_P32U_Enc, JMP, LoadEncKey);
  1886. + sc1442x_write_cmd(dev, RX_P32U_Enc, JMP, LoadEncState);
  1887. + sc1442x_write_cmd(dev, TX_P640j_Enc, JMP, LoadEncKey);
  1888. + sc1442x_write_cmd(dev, RX_P640j_Enc, JMP, LoadEncState);
  1889. + } else {
  1890. + sc1442x_write_cmd(dev, ClockSyncOn, P_SC, PSC_S_SYNC_ON);
  1891. + sc1442x_write_cmd(dev, ClockAdjust, EN_SL_ADJ, 1);
  1892. + sc1442x_write_cmd(dev, ClockSyncOff, P_SC, 0x00);
  1893. +
  1894. + sc1442x_write_cmd(dev, RX_P32U_Enc, JMP, LoadEncKey);
  1895. + sc1442x_write_cmd(dev, TX_P32U_Enc, JMP, LoadEncState);
  1896. + sc1442x_write_cmd(dev, RX_P640j_Enc, JMP, LoadEncKey);
  1897. + sc1442x_write_cmd(dev, TX_P640j_Enc, JMP, LoadEncState);
  1898. + }
  1899. +
  1900. + if (trx->mode == DECT_TRANSCEIVER_MASTER)
  1901. + sc1442x_write_cmd(dev, RFStart, BR, SlotTable);
  1902. + else {
  1903. + sc1442x_write_cmd(dev, RFStart, BR, SyncInit);
  1904. + sc1442x_write_cmd(dev, SyncLoop, BR, Sync);
  1905. + }
  1906. +
  1907. + sc1442x_start_dip(dect_transceiver_priv(trx));
  1908. +}
  1909. +
  1910. +static void sc1442x_confirm(const struct dect_transceiver *trx)
  1911. +{
  1912. + struct coa_device *dev = dect_transceiver_priv(trx);
  1913. +
  1914. + /*
  1915. + * This locks the firmware into a cycle where it will receive every
  1916. + * 24th slot. This must happen within the time it takes to transmit
  1917. + * 22 slots after the interrupt to lock to the correct signal.
  1918. + */
  1919. + sc1442x_lock_mem(dev);
  1920. + sc1442x_switch_to_bank(dev, SC1442X_CODEBANK);
  1921. + sc1442x_write_cmd(dev, SyncLoop, BR, SyncLock);
  1922. + sc1442x_unlock_mem(dev);
  1923. +}
  1924. +
  1925. +static void sc1442x_unlock(const struct dect_transceiver *trx)
  1926. +{
  1927. + struct coa_device *dev = dect_transceiver_priv(trx);
  1928. +
  1929. + /* Restore jump into Sync loop */
  1930. + sc1442x_lock_mem(dev);
  1931. + sc1442x_switch_to_bank(dev, SC1442X_CODEBANK);
  1932. + sc1442x_write_cmd(dev, SyncLoop, BR, Sync);
  1933. + sc1442x_write_cmd(dev, SlotTable, BR, SyncInit);
  1934. + sc1442x_unlock_mem(dev);
  1935. +}
  1936. +
  1937. +static void sc1442x_lock(const struct dect_transceiver *trx, u8 slot)
  1938. +{
  1939. + struct coa_device *dev = dect_transceiver_priv(trx);
  1940. +
  1941. + /*
  1942. + * We're receiving the single slot "slot". Adjust the firmware so it
  1943. + * will jump into the correct slottable position on the next receive
  1944. + * event. This will automagically establish the correct slot numbers
  1945. + * and thereby interrupt timing for all slots.
  1946. + */
  1947. + sc1442x_lock_mem(dev);
  1948. + sc1442x_switch_to_bank(dev, SC1442X_CODEBANK);
  1949. + sc1442x_write_cmd(dev, SlotTable, SLOTZERO, 0);
  1950. + sc1442x_write_cmd(dev, SyncLoop, BR, slottable[slot]);
  1951. + sc1442x_unlock_mem(dev);
  1952. +}
  1953. +
  1954. +static void sc1442x_write_bmc_config(const struct coa_device *dev,
  1955. + u8 slot, bool tx)
  1956. +{
  1957. + u16 off;
  1958. + u8 cfg;
  1959. +
  1960. + off = sc1442x_slot_offset(slot) + BMC_CTRL;
  1961. +
  1962. + cfg = 2 << SC1442X_BC0_S_ERR_SHIFT;
  1963. + cfg |= SC1442X_BC0_INV_TDO;
  1964. + cfg |= SC1442X_BC0_SENS_A;
  1965. + if (slot < 12 && !tx)
  1966. + cfg |= SC1442X_BC0_PP_MODE;
  1967. + sc1442x_dwriteb(dev, off + 0, cfg);
  1968. +
  1969. + /* S-field error mask */
  1970. + sc1442x_dwriteb(dev, off + 1, 0);
  1971. + /* S-field sliding window error mask */
  1972. + sc1442x_dwriteb(dev, off + 2, 0x3f);
  1973. +
  1974. + /* DAC output */
  1975. + sc1442x_dwriteb(dev, off + 3, 0);
  1976. +
  1977. + cfg = SC1442X_BC4_ADP;
  1978. + cfg |= 0xf & SC1442X_BC4_WIN_MASK;
  1979. + cfg |= 0x80;
  1980. + sc1442x_dwriteb(dev, off + 4, cfg);
  1981. +
  1982. + cfg = SC1442X_BC5_DO_FR;
  1983. + cfg |= tx ? SC1442X_BC5_TDO_DIGITAL : SC1442X_BC5_TDO_POWER_DOWN;
  1984. + sc1442x_dwriteb(dev, off + 5, cfg);
  1985. +
  1986. + /* Frame number */
  1987. + sc1442x_dwriteb(dev, off + 6, 0);
  1988. +}
  1989. +
  1990. +static void sc1442x_set_mode(const struct dect_transceiver *trx,
  1991. + const struct dect_channel_desc *chd,
  1992. + enum dect_slot_states mode)
  1993. +{
  1994. + struct coa_device *dev = dect_transceiver_priv(trx);
  1995. + bool cipher = trx->slots[chd->slot].flags & DECT_SLOT_CIPHER;
  1996. + bool sync = trx->slots[chd->slot].flags & DECT_SLOT_SYNC;
  1997. + u8 slot = chd->slot, prev = dect_slot_sub(slot, 1);
  1998. +
  1999. + sc1442x_lock_mem(dev);
  2000. + sc1442x_switch_to_bank(dev, SC1442X_CODEBANK);
  2001. +
  2002. + switch (mode) {
  2003. + case DECT_SLOT_IDLE:
  2004. + sc1442x_write_cmd(dev, slottable[prev] + 0, WT, 1);
  2005. + sc1442x_write_cmd(dev, slottable[prev] + 1, WNT, 1);
  2006. + sc1442x_write_cmd(dev, slottable[slot] + 0, WT, 1);
  2007. + sc1442x_write_cmd(dev, slottable[slot] + 1, WNT, 1);
  2008. + break;
  2009. + case DECT_SLOT_SCANNING:
  2010. + case DECT_SLOT_RX:
  2011. + sc1442x_write_cmd(dev, slottable[prev] + 0, BK_C,
  2012. + sc1442x_dip_bankaddress(slot));
  2013. + sc1442x_write_cmd(dev, slottable[prev] + 1, JMP, RFInit);
  2014. + sc1442x_write_cmd(dev, slottable[slot] + 0, WT, 1);
  2015. + sc1442x_write_cmd(dev, slottable[slot] + 1, JMP,
  2016. + sc1442x_rx_funcs[chd->pkt][chd->b_fmt][cipher][sync]);
  2017. +
  2018. + sc1442x_switch_to_bank(dev, sc1442x_slot_bank(slot));
  2019. + sc1442x_write_bmc_config(dev, slot, false);
  2020. + break;
  2021. + case DECT_SLOT_TX:
  2022. + sc1442x_write_cmd(dev, slottable[prev] + 0, BK_C,
  2023. + sc1442x_dip_bankaddress(slot));
  2024. + sc1442x_write_cmd(dev, slottable[prev] + 1, JMP, RFInit);
  2025. + sc1442x_write_cmd(dev, slottable[slot] + 0, WT, 1);
  2026. + sc1442x_write_cmd(dev, slottable[slot] + 1, JMP,
  2027. + sc1442x_tx_funcs[chd->pkt][chd->b_fmt][cipher]);
  2028. +
  2029. + sc1442x_switch_to_bank(dev, sc1442x_slot_bank(slot));
  2030. + sc1442x_write_bmc_config(dev, slot, true);
  2031. + break;
  2032. + }
  2033. + sc1442x_unlock_mem(dev);
  2034. +}
  2035. +
  2036. +static void sc1442x_set_carrier(const struct dect_transceiver *trx,
  2037. + u8 slot, u8 carrier)
  2038. +{
  2039. + const struct dect_transceiver_slot *ts = &trx->slots[slot];
  2040. + struct coa_device *dev = dect_transceiver_priv(trx);
  2041. + u16 off;
  2042. +
  2043. + WARN_ON(ts->state == DECT_SLOT_IDLE);
  2044. +
  2045. + sc1442x_lock_mem(dev);
  2046. + sc1442x_switch_to_bank(dev, sc1442x_slot_bank(slot));
  2047. + off = sc1442x_slot_offset(slot);
  2048. + dev->radio_ops->set_carrier(dev, off, ts->state, carrier);
  2049. + sc1442x_unlock_mem(dev);
  2050. +}
  2051. +
  2052. +static u64 sc1442x_set_band(const struct dect_transceiver *trx,
  2053. + const struct dect_band *band)
  2054. +{
  2055. + struct coa_device *dev = dect_transceiver_priv(trx);
  2056. +
  2057. + return dev->radio_ops->map_band(dev, band);
  2058. +}
  2059. +
  2060. +static void sc1442x_tx(const struct dect_transceiver *trx, struct sk_buff *skb)
  2061. +{
  2062. + struct coa_device *dev = dect_transceiver_priv(trx);
  2063. + const struct dect_skb_trx_cb *cb = DECT_TRX_CB(skb);
  2064. + const struct dect_transceiver_slot *ts = &trx->slots[cb->slot];
  2065. + u8 slot = cb->slot;
  2066. + u16 off;
  2067. +
  2068. + sc1442x_lock_mem(dev);
  2069. + sc1442x_switch_to_bank(dev, sc1442x_slot_bank(slot));
  2070. + off = sc1442x_slot_offset(slot);
  2071. +
  2072. + /* Duplicate first byte for transmission during ramp-up */
  2073. + sc1442x_dwriteb(dev, off + SD_PREAMBLE_OFF - 1, *skb_mac_header(skb));
  2074. + sc1442x_to_dmem(dev, off + SD_PREAMBLE_OFF,
  2075. + skb_mac_header(skb), skb->mac_len);
  2076. + sc1442x_to_dmem(dev, off + SD_DATA_OFF, skb->data, skb->len);
  2077. + sc1442x_dwriteb(dev, off + BMC_CTRL + BMC_CTRL_MFR_OFF, cb->frame);
  2078. +
  2079. + /* Init DCS for slots in the first half frame */
  2080. + if (ts->flags & DECT_SLOT_CIPHER && slot < DECT_HALF_FRAME_SIZE)
  2081. + sc1442x_dcs_init(dev, trx, slot, cb->mfn, cb->frame);
  2082. +
  2083. + sc1442x_toggle_led(dev);
  2084. + sc1442x_unlock_mem(dev);
  2085. + kfree_skb(skb);
  2086. +}
  2087. +
  2088. +const struct dect_transceiver_ops sc1442x_transceiver_ops = {
  2089. + .name = "sc1442x",
  2090. + .features = DECT_TRANSCEIVER_SLOW_HOPPING |
  2091. +#ifdef CONFIG_DECT_COA_P64
  2092. + DECT_TRANSCEIVER_PACKET_P64 |
  2093. +#endif
  2094. + 0,
  2095. + .eventrate = 6,
  2096. + .latency = 6,
  2097. + .disable = sc1442x_disable,
  2098. + .enable = sc1442x_enable,
  2099. + .confirm = sc1442x_confirm,
  2100. + .unlock = sc1442x_unlock,
  2101. + .lock = sc1442x_lock,
  2102. + .set_mode = sc1442x_set_mode,
  2103. + .set_carrier = sc1442x_set_carrier,
  2104. + .set_band = sc1442x_set_band,
  2105. + .tx = sc1442x_tx,
  2106. + .destructor = dect_transceiver_free,
  2107. +};
  2108. +EXPORT_SYMBOL_GPL(sc1442x_transceiver_ops);
  2109. +
  2110. +static u8 sc1442x_clear_interrupt(const struct coa_device *dev)
  2111. +{
  2112. + u8 int1, int2, cnt = 0;
  2113. +
  2114. + int1 = sc1442x_readb(dev, dev->cfg_reg);
  2115. + /* is the card still plugged? */
  2116. + if (int1 == 0xff)
  2117. + return 0;
  2118. +
  2119. + int2 = int1 & SC1442X_IRQ_MASK;
  2120. +
  2121. + /* Clear interrupt status before checking for any remaining events */
  2122. + if (int2 && dev->type == COA_TYPE_PCI)
  2123. + sc1442x_writeb(dev, SC14424_RESET_INT_PENDING_1, 0x80);
  2124. +
  2125. + while (int1) {
  2126. + cnt++;
  2127. + if (cnt > 254) {
  2128. + int2 = 0;
  2129. + break;
  2130. + }
  2131. +
  2132. + int1 = sc1442x_readb(dev, dev->cfg_reg) & SC1442X_IRQ_MASK;
  2133. + int2 |= int1;
  2134. + }
  2135. +
  2136. + return int2 & SC1442X_IRQ_MASK;
  2137. +}
  2138. +
  2139. +static void sc1442x_update_phase_offset(struct coa_device *dev,
  2140. + struct dect_transceiver_slot *ts,
  2141. + u8 framenum)
  2142. +{
  2143. + struct sc1442x_phase_state *ps = &dev->phase_state[ts->chd.slot / 2];
  2144. + u16 off = sc1442x_slot_offset(ts->chd.slot);
  2145. + s32 phaseoff;
  2146. + s8 phase;
  2147. + u8 tap;
  2148. +
  2149. + /* The phase offset is calculated from the differences of the tap and
  2150. + * phase status of two consequitive frames. The tap field contains
  2151. + * which of the nine internal clock cycles per symbol sampled the
  2152. + * incoming data and measures small scale frequency deviations up to
  2153. + * +-8 * 9.6ppm == +-86.4ppm. The phase field contains the absolute
  2154. + * phase offset in multiples of 87ppm.
  2155. + */
  2156. + tap = sc1442x_dreadb(dev, off + 2) >> SC1442X_ST2_TAP_SHIFT;
  2157. + phase = sc1442x_dreadb(dev, off + 3);
  2158. +
  2159. + if (dect_next_framenum(ps->framenum) == framenum) {
  2160. + phaseoff = (tap - ps->tap) * SC1442X_ST2_TAP_SCALE;
  2161. + phaseoff += (phase - ps->phase) * SC1442X_ST3_PHASE_SCALE;
  2162. +
  2163. + ts->phaseoff = dect_average_phase_offset(ts->phaseoff, phaseoff);
  2164. + }
  2165. +
  2166. + ps->framenum = framenum;
  2167. + ps->tap = tap;
  2168. + ps->phase = phase;
  2169. +}
  2170. +
  2171. +static void sc1442x_process_slot(struct coa_device *dev,
  2172. + struct dect_transceiver *trx,
  2173. + struct dect_transceiver_event *event,
  2174. + u8 slot)
  2175. +{
  2176. + struct dect_transceiver_slot *ts = &trx->slots[slot];
  2177. + struct sk_buff *skb;
  2178. + u8 status, framenum, csum, rssi;
  2179. + u32 mfn;
  2180. + u16 off;
  2181. +
  2182. + if (ts->state == DECT_SLOT_IDLE || ts->state == DECT_SLOT_TX)
  2183. + return;
  2184. +
  2185. + mfn = trx->cell->timer_base[DECT_TIMER_RX].mfn;
  2186. + framenum = trx->cell->timer_base[DECT_TIMER_RX].framenum;
  2187. +
  2188. + sc1442x_switch_to_bank(dev, sc1442x_slot_bank(slot));
  2189. + off = sc1442x_slot_offset(slot);
  2190. +
  2191. + /*
  2192. + * The SC1442X contains a 6 bit ADC for RSSI measurement, convert to
  2193. + * units used by the stack.
  2194. + */
  2195. + status = sc1442x_dreadb(dev, off + SD_RSSI_OFF);
  2196. + rssi = (status & SC1442X_ST0_ADC_MASK) * DECT_RSSI_RANGE / 63;
  2197. +
  2198. + /* validate and clear checksum */
  2199. + status = sc1442x_dreadb(dev, off + SD_CSUM_OFF);
  2200. + if (!(status & SC1442X_ST1_IN_SYNC))
  2201. + goto out;
  2202. + sc1442x_dwriteb(dev, off + SD_CSUM_OFF, 0);
  2203. +
  2204. + if (!(status & SC1442X_ST1_A_CRC)) {
  2205. + ts->rx_a_crc_errors++;
  2206. + if (ts->chd.pkt == DECT_PACKET_P00)
  2207. + goto out;
  2208. + csum = 0;
  2209. + } else
  2210. + csum = DECT_CHECKSUM_A_CRC_OK;
  2211. +
  2212. + if (ts->chd.pkt != DECT_PACKET_P00) {
  2213. + if (!(status & SC1442X_ST1_X_CRC))
  2214. + ts->rx_x_crc_errors++;
  2215. + else
  2216. + csum |= DECT_CHECKSUM_X_CRC_OK;
  2217. +
  2218. + if (!(status & SC1442X_ST1_Z_CRC))
  2219. + ts->rx_z_crc_errors++;
  2220. + else
  2221. + csum |= DECT_CHECKSUM_Z_CRC_OK;
  2222. + }
  2223. +
  2224. + /* calculate phase offset */
  2225. + sc1442x_update_phase_offset(dev, ts, framenum);
  2226. +
  2227. + skb = dect_transceiver_alloc_skb(trx, slot);
  2228. + if (skb == NULL)
  2229. + goto out;
  2230. + sc1442x_from_dmem(dev, skb->data, off + SD_DATA_OFF, skb->len);
  2231. + DECT_TRX_CB(skb)->csum = csum;
  2232. + DECT_TRX_CB(skb)->rssi = rssi;
  2233. + __skb_queue_tail(&event->rx_queue, skb);
  2234. +
  2235. + ts->rx_bytes += skb->len;
  2236. + ts->rx_packets++;
  2237. +
  2238. + sc1442x_toggle_led(dev);
  2239. +out:
  2240. + ts->rssi = dect_average_rssi(ts->rssi, rssi);
  2241. + dect_transceiver_record_rssi(event, slot, rssi);
  2242. +
  2243. + /* Update frame number for next reception */
  2244. + sc1442x_dwriteb(dev, off + BMC_CTRL + BMC_CTRL_MFR_OFF, framenum + 1);
  2245. +
  2246. + /* Init DCS for slots in the first half frame */
  2247. + if (ts->flags & DECT_SLOT_CIPHER && slot < DECT_HALF_FRAME_SIZE)
  2248. + sc1442x_dcs_init(dev, trx, slot, mfn, framenum + 1);
  2249. +}
  2250. +
  2251. +irqreturn_t sc1442x_interrupt(int irq, void *dev_id)
  2252. +{
  2253. + struct dect_transceiver *trx = dev_id;
  2254. + struct coa_device *dev = dect_transceiver_priv(trx);
  2255. + struct dect_transceiver_event *event;
  2256. + u8 slot, i;
  2257. +
  2258. + irq = sc1442x_clear_interrupt(dev);
  2259. + if (!irq)
  2260. + return IRQ_NONE;
  2261. +
  2262. + if (unlikely(hweight8(irq) != 1 && net_ratelimit()))
  2263. + dev_info(dev->dev, "lost some interrupts\n");
  2264. +
  2265. + for (i = 0; i < 4; i++) {
  2266. + if (!(irq & (1 << i)))
  2267. + continue;
  2268. +
  2269. + event = dect_transceiver_event(trx, i % 2, i * 6);
  2270. + if (event == NULL)
  2271. + goto out;
  2272. +
  2273. + spin_lock(&dev->lock);
  2274. + for (slot = 6 * i; slot < 6 * (i + 1); slot++) {
  2275. + sc1442x_process_slot(dev, trx, event, slot);
  2276. + if (slot < DECT_HALF_FRAME_SIZE)
  2277. + sc1442x_transfer_dcs_state(dev, trx, slot);
  2278. + }
  2279. + spin_unlock(&dev->lock);
  2280. +
  2281. + dect_transceiver_queue_event(trx, event);
  2282. + }
  2283. +out:
  2284. + return IRQ_HANDLED;
  2285. +}
  2286. +EXPORT_SYMBOL_GPL(sc1442x_interrupt);
  2287. +
  2288. +static void sc1442x_init_slot(const struct coa_device *dev, u8 slot)
  2289. +{
  2290. + u16 off;
  2291. +
  2292. + sc1442x_switch_to_bank(dev, sc1442x_slot_bank(slot));
  2293. + off = sc1442x_slot_offset(slot);
  2294. + dev->radio_ops->rx_init(dev, off);
  2295. + dev->radio_ops->tx_init(dev, off);
  2296. +}
  2297. +
  2298. +static int sc1442x_check_dram(const struct coa_device *dev)
  2299. +{
  2300. + unsigned int bank, i;
  2301. + unsigned int cnt;
  2302. + u16 off;
  2303. + u8 val;
  2304. +
  2305. + for (bank = 0; bank < 8; bank++) {
  2306. + sc1442x_switch_to_bank(dev, 4 * bank);
  2307. +
  2308. + off = bank * SC1442X_BANKSIZE;
  2309. + for (i = 0; i < SC1442X_BANKSIZE - 2; i++)
  2310. + sc1442x_dwriteb(dev, off + i, bank + i);
  2311. + }
  2312. +
  2313. + cnt = 0;
  2314. + for (bank = 0; bank < 8; bank++) {
  2315. + sc1442x_switch_to_bank(dev, 4 * bank);
  2316. +
  2317. + off = bank * SC1442X_BANKSIZE;
  2318. + for (i = 0; i < SC1442X_BANKSIZE - 2; i++) {
  2319. + val = sc1442x_dreadb(dev, off + i);
  2320. + if (val != ((bank + i) & 0xff)) {
  2321. + dev_err(dev->dev,
  2322. + "memory error bank %.2x offset %.2x: "
  2323. + "%.2x != %.2x\n", bank, i,
  2324. + val, (bank + i) & 0xff);
  2325. + cnt++;
  2326. + }
  2327. + sc1442x_dwriteb(dev, off + i, 0);
  2328. + }
  2329. + }
  2330. +
  2331. + if (cnt > 0)
  2332. + dev_err(dev->dev, "found %u memory r/w errors\n", cnt);
  2333. + return cnt ? -1 : 0;
  2334. +}
  2335. +
  2336. +int sc1442x_init_device(struct coa_device *dev)
  2337. +{
  2338. + unsigned int i;
  2339. + u8 slot;
  2340. +
  2341. + spin_lock_init(&dev->lock);
  2342. + dev->ctrl = SC1442X_DIPSTOPPED;
  2343. +
  2344. + if (sc1442x_check_dram(dev) < 0)
  2345. + return -EIO;
  2346. +
  2347. + dev_info(dev->dev, "Loading firmware ...\n");
  2348. + sc1442x_switch_to_bank(dev, SC1442X_CODEBANK);
  2349. + sc1442x_to_cmem(dev, sc1442x_firmware, sizeof(sc1442x_firmware));
  2350. +
  2351. + sc1442x_clear_interrupt(dev);
  2352. +
  2353. + /* Init DIP */
  2354. + sc1442x_switch_to_bank(dev, SC1442X_RAMBANK0);
  2355. +
  2356. + /* Disable Codec */
  2357. + sc1442x_dwriteb(dev, DIP_CC_INIT, SC1442X_CC0_STANDBY);
  2358. + for (i = 1; i < SC1442X_CC_SIZE; i++)
  2359. + sc1442x_dwriteb(dev, DIP_CC_INIT + i, 0);
  2360. +
  2361. + for (slot = 0; slot < DECT_FRAME_SIZE; slot += 2)
  2362. + sc1442x_init_slot(dev, slot);
  2363. +
  2364. + if (dev->type == COA_TYPE_PCI) {
  2365. + /* Enable DIP interrupt */
  2366. + sc1442x_writeb(dev, SC14424_INT_PRIORITY_1, 0x70);
  2367. + /* Enable SPI for LED control */
  2368. + sc1442x_writeb(dev, SC14424_P1_DIR_REG, 0xd6);
  2369. + }
  2370. + return 0;
  2371. +}
  2372. +EXPORT_SYMBOL_GPL(sc1442x_init_device);
  2373. +
  2374. +void sc1442x_shutdown_device(struct coa_device *dev)
  2375. +{
  2376. + sc1442x_stop_dip(dev);
  2377. +
  2378. + if (dev->type == COA_TYPE_PCI) {
  2379. + /* Clear pening interrupts */
  2380. + sc1442x_writeb(dev, SC14424_RESET_INT_PENDING_1, 0xff);
  2381. + sc1442x_writeb(dev, SC14424_RESET_INT_PENDING_2, 0xff);
  2382. + /* Reset LED */
  2383. + sc1442x_writeb(dev, SC14424_P1_RESET_OUTPUT_DATA, 0x40);
  2384. + }
  2385. +}
  2386. +EXPORT_SYMBOL_GPL(sc1442x_shutdown_device);
  2387. +
  2388. +MODULE_LICENSE("GPL");
  2389. diff --git a/drivers/dect/coa/sc1442x_firmware.asm b/drivers/dect/coa/sc1442x_firmware.asm
  2390. new file mode 100644
  2391. index 0000000..c8097f8
  2392. --- /dev/null
  2393. +++ b/drivers/dect/coa/sc1442x_firmware.asm
  2394. @@ -0,0 +1,429 @@
  2395. + CPU SC14421
  2396. + ORG 0
  2397. +
  2398. + BR Start
  2399. +
  2400. +PB_LED EQU 0x80
  2401. +PB_RX_ON EQU 0x40
  2402. +PB_TX_ON EQU 0x10
  2403. +PB_RADIOPOWER EQU 0x04
  2404. +PB_DCTHRESHOLD EQU 0x02
  2405. +PB_RSSI EQU 0x01
  2406. +
  2407. +; synchronisation control
  2408. +PSC_ARPD1 EQU 0x80
  2409. +PSC_S_SYNC EQU 0x40
  2410. +PSC_S_SYNC_ON EQU 0x20
  2411. +PSC_EOPSM EQU 0x10
  2412. +
  2413. +; memory banks 0-7, lower and upper halfs (128 bytes each)
  2414. +BANK0_LOW EQU 0x00
  2415. +BANK0_HIGH EQU 0x10
  2416. +BANK1_LOW EQU 0x20
  2417. +BANK1_HIGH EQU 0x30
  2418. +BANK2_LOW EQU 0x40
  2419. +BANK2_HIGH EQU 0x50
  2420. +BANK3_LOW EQU 0x60
  2421. +BANK3_HIGH EQU 0x70
  2422. +BANK4_LOW EQU 0x80
  2423. +BANK4_HIGH EQU 0x90
  2424. +BANK5_LOW EQU 0xa0
  2425. +BANK5_HIGH EQU 0xb0
  2426. +BANK6_LOW EQU 0xc0
  2427. +BANK6_HIGH EQU 0xd0
  2428. +BANK7_LOW EQU 0xe0
  2429. +BANK7_HIGH EQU 0xf0
  2430. +
  2431. +; Codec Control
  2432. +DIP_CC_INIT EQU 0x10
  2433. +
  2434. +; Radio configuration word
  2435. +RF_DESC EQU 0x65
  2436. +
  2437. +; BMC control information
  2438. +BMC_CTRL_SIZE EQU 7
  2439. +BMC_CTRL EQU 0x69
  2440. +
  2441. +; (multi) frame number for scambler and DCS
  2442. +BMC_CTRL_MFR_OFF EQU 6
  2443. +
  2444. +; Cipher IV/Key
  2445. +DCS_DESC EQU 0x70
  2446. +DCS_IV EQU DCS_DESC
  2447. +DCS_CK EQU DCS_DESC + 0x8
  2448. +
  2449. +; Cipher state
  2450. +DCS_STATE EQU 0x70
  2451. +DCS_STATE_SIZE EQU 11
  2452. +
  2453. +SD_PREAMBLE_OFF EQU 0x01
  2454. +SD_A_FIELD_OFF EQU 0x06
  2455. +SD_B_FIELD_OFF EQU 0x0E
  2456. +
  2457. +; status descriptor
  2458. +SD_BASE_OFF EQU 0x00
  2459. +SD_RSSI_OFF EQU 0x00
  2460. +SD_CSUM_OFF EQU 0x01
  2461. +SD_DATA_OFF EQU 0x06
  2462. +
  2463. +; U2785 radio
  2464. +U2785_CFG1_LEN EQU 24
  2465. +U2785_CFG2_LEN EQU 9
  2466. +
  2467. +;-------------------------------------------------------------
  2468. +
  2469. +Start: BR InitDIP
  2470. +;-------------------------------------------------------------
  2471. +
  2472. +SlotTable: SLOTZERO
  2473. +
  2474. +Slot00: WT 1
  2475. + WNT 1
  2476. +Slot01: WT 1
  2477. + WNT 1
  2478. +Slot02: WT 1
  2479. + WNT 1
  2480. +Slot03: WT 1
  2481. + WNT 1
  2482. +Slot04: WT 1
  2483. + WNT 1
  2484. +Slot05: WT 1
  2485. + WNT 1
  2486. + U_INT0
  2487. +
  2488. +Slot06: WT 1
  2489. + WNT 1
  2490. +Slot07: WT 1
  2491. + WNT 1
  2492. +Slot08: WT 1
  2493. + WNT 1
  2494. +Slot09: WT 1
  2495. + WNT 1
  2496. +Slot10: WT 1
  2497. + WNT 1
  2498. +Slot11: WT 1
  2499. + WNT 1
  2500. + U_INT1
  2501. +
  2502. +Slot12: WT 1
  2503. + WNT 1
  2504. +Slot13: WT 1
  2505. + WNT 1
  2506. +Slot14: WT 1
  2507. + WNT 1
  2508. +Slot15: WT 1
  2509. + WNT 1
  2510. +Slot16: WT 1
  2511. + WNT 1
  2512. +Slot17: WT 1
  2513. + WNT 1
  2514. + U_INT2
  2515. +
  2516. +Slot18: WT 1
  2517. + WNT 1
  2518. +Slot19: WT 1
  2519. + WNT 1
  2520. +Slot20: WT 1
  2521. + WNT 1
  2522. +Slot21: WT 1
  2523. + WNT 1
  2524. +Slot22: WT 1
  2525. + WNT 1
  2526. +Slot23: WT 1
  2527. + WNT 1
  2528. + U_INT3
  2529. +
  2530. + BR SlotTable
  2531. +
  2532. +;-------------------------------------------------------------------------------
  2533. +; Receive a P00 packet
  2534. +;
  2535. +RX_P00: JMP Receive ; Receive S- and beginning of A-field |
  2536. +RX_P00_End: B_BRFU SD_B_FIELD_OFF ; Receive unprotected full-slot B-field | p: 95 A: 63
  2537. + JMP ReceiveEnd ; End reception | p: 96 B: 0
  2538. + BR WriteBMC1 ;
  2539. +
  2540. +RX_P00_Sync: JMP ReceiveSync ; Receive S- and beginning of A-field |
  2541. + BR RX_P00_End
  2542. +
  2543. +; Receive a P32 packet using the the unprotected full slot B-field format in
  2544. +; the D32-field
  2545. +;
  2546. +RX_P32U_Enc: JMP LoadEncKey
  2547. +RX_P32U: JMP Receive
  2548. + B_BRFU SD_B_FIELD_OFF ; Receive unprotected full-slot B-field | p: 95 A: 63
  2549. + JMP RX_P32U_BZ ; Receive B-field | p: 96 B: 0
  2550. + BR WriteBMC2
  2551. +
  2552. +RX_P640j_Enc: JMP LoadEncKey
  2553. +RX_P640j: JMP Receive
  2554. + B_BR SD_B_FIELD_OFF
  2555. + JMP Transfer_P640j
  2556. + WT 14 ; 15 - 1 (RTN)
  2557. + B_XR
  2558. + JMP ReceiveEnd
  2559. + BR WriteBMC2
  2560. +
  2561. +;-------------------------------------------------------------------------------
  2562. +; Transmit a P00 packet
  2563. +;
  2564. +TX_P00: JMP Transmit ; Transmit S- and beginning of A-field |
  2565. + JMP TransmitEnd ; End transmission | p: 94 A: 62
  2566. + BR label_53 ;
  2567. +
  2568. +; Transmit a P32 packet using the unprotected full slot B-field format in the
  2569. +; D32-field
  2570. +;
  2571. +TX_P32U_Enc: JMP LoadEncKey
  2572. +TX_P32U: JMP Transmit ; Transmit S- and beginning of A-field |
  2573. + B_BTFU SD_B_FIELD_OFF ; Transmit unprotected full-slot B-field data | p: 95 A: 63
  2574. + JMP TX_P32U_BZ ; Transmit the B- and Z-fields | p: 96 B: 0
  2575. + BR label_54 ;
  2576. +
  2577. +TX_P640j_Enc: JMP LoadEncKey
  2578. +TX_P640j: JMP Transmit
  2579. + B_BT SD_B_FIELD_OFF
  2580. + WT 3 ; B_BT has 3 bits of latency
  2581. + JMP Transfer_P640j
  2582. + WT 11 ; 15 - 1 (RTN) - 3 (latency)
  2583. + B_XT
  2584. + WT 13 ; 8 (X/Z-Field) + 5
  2585. + B_RST
  2586. + JMP TransmitEnd
  2587. + BR label_58
  2588. +
  2589. +Transfer_B: WT 45 ; 47 - 2 (JMP/JMP, JMP/RTN)
  2590. + B_XON
  2591. + WT 15
  2592. + B_XOFF
  2593. + RTN
  2594. +
  2595. +Transfer_P640j: JMP Transfer_B
  2596. + JMP Transfer_B
  2597. + JMP Transfer_B
  2598. + JMP Transfer_B
  2599. + JMP Transfer_B
  2600. + JMP Transfer_B
  2601. + JMP Transfer_B
  2602. + JMP Transfer_B
  2603. + JMP Transfer_B
  2604. + WT 46 ; 47 - 1 (RTN)
  2605. + B_XON
  2606. + RTN
  2607. +
  2608. +;-------------------------------------------------------------------------------
  2609. +WriteBMC1: B_WRS SD_BASE_OFF ; write status
  2610. + WT 6
  2611. +
  2612. +label_53: B_RST
  2613. +label_54: P_LDL PB_RX_ON | PB_TX_ON
  2614. + WT 5
  2615. + WNT 1
  2616. + RTN
  2617. +
  2618. +;-------------------------------------------------------------------------------
  2619. +WriteBMC2: B_WRS SD_BASE_OFF ; write status
  2620. + WT 6
  2621. +label_58: B_RST
  2622. + P_LDL PB_RX_ON | PB_TX_ON
  2623. + RTN
  2624. +
  2625. +
  2626. +ReceiveInit: B_RST
  2627. + B_RC BMC_CTRL
  2628. + WT BMC_CTRL_SIZE + 1
  2629. + P_LDH PB_RX_ON
  2630. + P_LDL PB_RSSI ; enable RSSI measurement
  2631. + WT 25
  2632. + WNT 1 ; Wait until beginning of slot |
  2633. + WT 7 ; | p: -33--26
  2634. + RTN
  2635. +
  2636. +;-------------------------------------------------------------------------------
  2637. +; Enable the receiver, receive the S-field and the first 61 bits of the D-field
  2638. +; (93 bits total)
  2639. +;
  2640. +Receive: JMP ReceiveInit
  2641. + B_XON ; | p: -25
  2642. +ClockSyncOn: P_SC PSC_S_SYNC_ON ; | p: -24
  2643. + P_LDH PB_DCTHRESHOLD ; | p: -23
  2644. + WT 5 ; | p: -22--16
  2645. + B_SR ; Receive S-field | p: -17
  2646. +ClockAdjust: EN_SL_ADJ ; | p: -16 S: 0
  2647. + WT 12 ; | p: -15--4 S: 1-12
  2648. + P_LDL PB_DCTHRESHOLD ; | p: -3 S: 13
  2649. + WT 32 ; | p: -2-29 S: 14-45
  2650. +ClockSyncOff: P_SC 0x00 ; | p: 30 S: 46
  2651. + B_AR2 SD_A_FIELD_OFF ; Start reception of A-field/A-field CRC | p: 31 S: 47
  2652. + WT 62 ; Receive first 61 bits of A-field | p: 32-92 A: 0-60
  2653. + RTN ; Return | p: 93 A: 61
  2654. +
  2655. +ReceiveSync: JMP ReceiveInit
  2656. + B_XON ; | p: -25
  2657. + P_SC PSC_S_SYNC_ON ; | p: -24
  2658. + P_LDH PB_DCTHRESHOLD ; | p: -23
  2659. + WT 5 ; | p: -22--16
  2660. + B_SR ; Receive S-field | p: -17
  2661. + EN_SL_ADJ ; | p: -16 S: 0
  2662. + WT 12 ; | p: -15--4 S: 1-12
  2663. + P_LDL PB_DCTHRESHOLD ; | p: -3 S: 13
  2664. + WT 32 ; | p: -2-29 S: 14-45
  2665. + P_SC 0x00 ; | p: 30 S: 46
  2666. + B_AR2 SD_A_FIELD_OFF ; Start reception of A-field/A-field CRC | p: 31 S: 47
  2667. + WT 61 ; Receive first 61 bits of A-field | p: 32-92 A: 0-60
  2668. + RTN ; Return | p: 93 A: 61
  2669. +
  2670. +; Receive the B- and Z-fields of a P32 packet using the protected full slot
  2671. +; B-field format in the D32-field
  2672. +RX_P32U_BZ: WT 249 ; | p: 97-345 B: 1-249
  2673. + WT 79 ; | p: 346-415 B: 250-319
  2674. + ; | p: 416-419 B: 320-323 X: 0-3
  2675. + ; | p: 420-423 Z: 0- 3
  2676. + ; | p: 424 ??
  2677. +ReceiveEnd: P_LDH PB_RSSI ; |
  2678. + P_LDL PB_RX_ON
  2679. + BR SaveEncState
  2680. +;-------------------------------------------------------------------------------
  2681. +; Enable transmitter, transmit the S-field and the first 61 bits of the D-field
  2682. +; (93 bits total)
  2683. +;
  2684. +Transmit: P_LDH 0x00 ;
  2685. + WT 40 ;
  2686. + B_RST ;
  2687. + B_RC BMC_CTRL ;
  2688. + WNT 1 ; Wait until beginning of slot
  2689. + B_ST 0x00 ; Start transmission of S-field data |
  2690. + WT 1 ; Wait one bit | p: -8 S: 0
  2691. + P_LDH PB_TX_ON ; Enable transmitter | p: -7 S: 1
  2692. + WT 37 ; Transmit 29 bits S-field | p: -6-30 S: 2-38
  2693. + B_AT2 SD_A_FIELD_OFF ; Start transission of A-field data/A-field CRC | p: 31 S: 39
  2694. + WT 62 ; Transmit first 61 bits of A-field | p: 32-92 A: 0-60
  2695. + RTN ; Return | p: 93 A: 61
  2696. +
  2697. +;-------------------------------------------------------------------------------
  2698. +;
  2699. +;
  2700. +TX_P32U_BZ: WT 249 ; | p: 97-345 B: 1-249
  2701. + WT 84 ; Last bits of B-field data | p: 346-415 B: 250-319
  2702. + ; X-field | p: 416-419 B: 320-323 X: 0-3
  2703. + ; Z-field (?) | p: 420-424 Z: 0- 3
  2704. + ; 5 bits of crap? | p: 425-429
  2705. + B_RST ; Reset BMC | p: 430
  2706. +
  2707. +TransmitEnd: P_LDL PB_TX_ON ; Disable transmitter |
  2708. + WT 8 ; Wait until transmitter is disabled |
  2709. + P_LDL 0x00 ;
  2710. + BR SaveEncState
  2711. +
  2712. +;-------------------------------------------------------------------------------
  2713. +
  2714. +RFInit: RFEN ; Enable RF-clock
  2715. + WT 2
  2716. +
  2717. + MEN1N ; Transfer first radio configuration word
  2718. + M_WR RF_DESC
  2719. + WT U2785_CFG1_LEN + 1
  2720. + M_RST
  2721. + MEN1
  2722. +
  2723. + MEN1N ; Transfer second radio configuration word
  2724. + M_WR RF_DESC + U2785_CFG1_LEN / 8
  2725. + WT U2785_CFG2_LEN + 1
  2726. + M_RST
  2727. + MEN1
  2728. + ;WT 1
  2729. +
  2730. + P_LDL 0x20
  2731. + WT 10
  2732. + IFNDEF ENABLE_P64
  2733. + MEN2
  2734. + WT 182
  2735. + MEN2N
  2736. + WT 16
  2737. + ENDIF
  2738. + RTN
  2739. +;--------------------------------------------------------------
  2740. +;
  2741. +LoadEncKey: D_RST
  2742. + D_LDK DCS_DESC ; load IV (64 bits) and cipher key (64 bits)
  2743. + WT 16
  2744. + D_LDK 0
  2745. + D_PREP 0
  2746. + WT 39
  2747. + D_PREP 0
  2748. + RTN
  2749. +
  2750. +SaveEncState: D_WRS DCS_STATE
  2751. + WT DCS_STATE_SIZE ; actually should be -1, but does not work
  2752. + D_WRS 0
  2753. + D_RST
  2754. + RTN
  2755. +
  2756. +LoadEncState: D_RST
  2757. + D_LDS DCS_STATE
  2758. + WT DCS_STATE_SIZE ; actually should be -1, but does not work
  2759. + D_LDS 0
  2760. + RTN
  2761. +;-------------------------------------------------------------
  2762. +
  2763. +SyncInit: BK_C BANK1_LOW
  2764. +Sync: JMP RFInit
  2765. + WT 250
  2766. + P_SC PSC_S_SYNC_ON
  2767. + P_LDH PB_RX_ON | PB_DCTHRESHOLD
  2768. + UNLCK
  2769. + WT 64
  2770. + B_XOFF
  2771. + B_SR
  2772. + WNT 20
  2773. + JMP1 SFieldFound
  2774. + B_RST
  2775. + U_INT1
  2776. + WNT 23
  2777. + BR Sync
  2778. +;-------------------------------------------------------------
  2779. +
  2780. +SFieldFound: WNT 23
  2781. + P_SC 0x00
  2782. +SyncLock: JMP RFInit
  2783. + JMP RX_P00
  2784. + U_INT0
  2785. + WNT 22
  2786. +SyncLoop: BR Sync
  2787. +;-------------------------------------------------------------
  2788. +
  2789. +InitDIP: ;B_RST
  2790. + BK_C BANK0_LOW
  2791. + C_LD DIP_CC_INIT
  2792. + WT 10
  2793. + ;B_RC BMC_CTRL
  2794. + ;WT BMC_CTRL_SIZE + 1
  2795. + ;B_RST
  2796. + C_ON
  2797. + WT 10
  2798. + P_EN
  2799. + P_LD 0x04
  2800. + RCK_INT
  2801. + RFEN
  2802. +RFStart: BR SyncInit
  2803. +;-------------------------------------------------------------
  2804. +
  2805. + SHARED DIP_CC_INIT,RF_DESC
  2806. + SHARED BMC_CTRL,BMC_CTRL_MFR_OFF
  2807. + SHARED SD_RSSI_OFF,SD_CSUM_OFF,SD_PREAMBLE_OFF,SD_DATA_OFF
  2808. +
  2809. + SHARED SlotTable
  2810. + SHARED Slot00,Slot01,Slot02,Slot03,Slot04,Slot05,Slot06,Slot07
  2811. + SHARED Slot08,Slot09,Slot10,Slot11,Slot12,Slot13,Slot14,Slot15
  2812. + SHARED Slot16,Slot17,Slot18,Slot19,Slot20,Slot21,Slot22,Slot23
  2813. +
  2814. + SHARED RFStart,RFInit
  2815. + SHARED SyncInit,Sync,SyncLock,SyncLoop
  2816. + SHARED ClockSyncOn,ClockSyncOff,ClockAdjust
  2817. + SHARED PSC_ARPD1,PSC_S_SYNC,PSC_S_SYNC_ON,PSC_EOPSM
  2818. +
  2819. + SHARED RX_P00,RX_P00_Sync,RX_P32U,RX_P32U_Enc,RX_P640j,RX_P640j_Enc
  2820. + SHARED TX_P00,TX_P32U,TX_P32U_Enc,TX_P640j,TX_P640j_Enc
  2821. +
  2822. + SHARED DCS_IV,DCS_CK,DCS_STATE,DCS_STATE_SIZE
  2823. + SHARED LoadEncKey,LoadEncState
  2824. diff --git a/drivers/dect/coa/sc1442x_firmware.c b/drivers/dect/coa/sc1442x_firmware.c
  2825. new file mode 100644
  2826. index 0000000..d1fea60
  2827. --- /dev/null
  2828. +++ b/drivers/dect/coa/sc1442x_firmware.c
  2829. @@ -0,0 +1,73 @@
  2830. +/*
  2831. + * automatically generated file
  2832. + * DO NOT EDIT
  2833. + * edit firmware/filename.asm instead
  2834. + */
  2835. +
  2836. +#include "sc1442x_firmware.h"
  2837. +
  2838. +const unsigned char sc1442x_firmware[] = {
  2839. + 0x01, 0x01, 0x01, 0xef, 0x0d, 0x00, 0x09, 0x01,
  2840. + 0x08, 0x01, 0x09, 0x01, 0x08, 0x01, 0x09, 0x01,
  2841. + 0x08, 0x01, 0x09, 0x01, 0x08, 0x01, 0x09, 0x01,
  2842. + 0x08, 0x01, 0x09, 0x01, 0x08, 0x01, 0x61, 0x00,
  2843. + 0x09, 0x01, 0x08, 0x01, 0x09, 0x01, 0x08, 0x01,
  2844. + 0x09, 0x01, 0x08, 0x01, 0x09, 0x01, 0x08, 0x01,
  2845. + 0x09, 0x01, 0x08, 0x01, 0x09, 0x01, 0x08, 0x01,
  2846. + 0x6b, 0x00, 0x09, 0x01, 0x08, 0x01, 0x09, 0x01,
  2847. + 0x08, 0x01, 0x09, 0x01, 0x08, 0x01, 0x09, 0x01,
  2848. + 0x08, 0x01, 0x09, 0x01, 0x08, 0x01, 0x09, 0x01,
  2849. + 0x08, 0x01, 0x6d, 0x00, 0x09, 0x01, 0x08, 0x01,
  2850. + 0x09, 0x01, 0x08, 0x01, 0x09, 0x01, 0x08, 0x01,
  2851. + 0x09, 0x01, 0x08, 0x01, 0x09, 0x01, 0x08, 0x01,
  2852. + 0x09, 0x01, 0x08, 0x01, 0x6f, 0x00, 0x01, 0x02,
  2853. + 0x02, 0x84, 0x2d, 0x0e, 0x02, 0xa2, 0x01, 0x6f,
  2854. + 0x02, 0x92, 0x01, 0x39, 0x02, 0xc7, 0x02, 0x84,
  2855. + 0x2d, 0x0e, 0x02, 0xa0, 0x01, 0x76, 0x02, 0xc7,
  2856. + 0x02, 0x84, 0x3c, 0x0e, 0x02, 0x63, 0x09, 0x0e,
  2857. + 0x2b, 0x00, 0x02, 0xa2, 0x01, 0x76, 0x02, 0xa5,
  2858. + 0x02, 0xb4, 0x01, 0x71, 0x02, 0xc7, 0x02, 0xa5,
  2859. + 0x25, 0x0e, 0x02, 0xb1, 0x01, 0x72, 0x02, 0xc7,
  2860. + 0x02, 0xa5, 0x34, 0x0e, 0x09, 0x03, 0x02, 0x63,
  2861. + 0x09, 0x0b, 0x24, 0x00, 0x09, 0x0d, 0x20, 0x00,
  2862. + 0x02, 0xb4, 0x01, 0x78, 0x09, 0x2d, 0x27, 0x00,
  2863. + 0x09, 0x0f, 0x26, 0x00, 0x04, 0x00, 0x02, 0x5e,
  2864. + 0x02, 0x5e, 0x02, 0x5e, 0x02, 0x5e, 0x02, 0x5e,
  2865. + 0x02, 0x5e, 0x02, 0x5e, 0x02, 0x5e, 0x02, 0x5e,
  2866. + 0x09, 0x2e, 0x27, 0x00, 0x04, 0x00, 0x39, 0x00,
  2867. + 0x09, 0x06, 0x20, 0x00, 0xec, 0x50, 0x09, 0x05,
  2868. + 0x08, 0x01, 0x04, 0x00, 0x39, 0x00, 0x09, 0x06,
  2869. + 0x20, 0x00, 0xec, 0x50, 0x04, 0x00, 0x20, 0x00,
  2870. + 0x33, 0x69, 0x09, 0x08, 0xed, 0x40, 0xec, 0x01,
  2871. + 0x09, 0x19, 0x08, 0x01, 0x09, 0x07, 0x04, 0x00,
  2872. + 0x02, 0x7b, 0x27, 0x00, 0xea, 0x20, 0xed, 0x02,
  2873. + 0x09, 0x05, 0x29, 0x00, 0x2c, 0x00, 0x09, 0x0c,
  2874. + 0xec, 0x02, 0x09, 0x20, 0xea, 0x00, 0x3f, 0x06,
  2875. + 0x09, 0x3e, 0x04, 0x00, 0x02, 0x7b, 0x27, 0x00,
  2876. + 0xea, 0x20, 0xed, 0x02, 0x09, 0x05, 0x29, 0x00,
  2877. + 0x2c, 0x00, 0x09, 0x0c, 0xec, 0x02, 0x09, 0x20,
  2878. + 0xea, 0x00, 0x3f, 0x06, 0x09, 0x3d, 0x04, 0x00,
  2879. + 0x09, 0xf9, 0x09, 0x4f, 0xed, 0x01, 0xec, 0x40,
  2880. + 0x01, 0xcf, 0xed, 0x00, 0x09, 0x28, 0x20, 0x00,
  2881. + 0x33, 0x69, 0x08, 0x01, 0x31, 0x00, 0x09, 0x01,
  2882. + 0xed, 0x10, 0x09, 0x25, 0x37, 0x06, 0x09, 0x3e,
  2883. + 0x04, 0x00, 0x09, 0xf9, 0x09, 0x54, 0x20, 0x00,
  2884. + 0xec, 0x10, 0x09, 0x08, 0xec, 0x00, 0x01, 0xcf,
  2885. + 0x0b, 0x00, 0x09, 0x02, 0xa4, 0x00, 0xb9, 0x65,
  2886. + 0x09, 0x19, 0xa9, 0x00, 0xa5, 0x00, 0xa4, 0x00,
  2887. + 0xb9, 0x68, 0x09, 0x0a, 0xa9, 0x00, 0xa5, 0x00,
  2888. + 0xec, 0x20, 0x09, 0x0a, 0x04, 0x00, 0x40, 0x00,
  2889. + 0x50, 0x70, 0x09, 0x10, 0x50, 0x00, 0x44, 0x00,
  2890. + 0x09, 0x27, 0x44, 0x00, 0x04, 0x00, 0x5f, 0x70,
  2891. + 0x09, 0x0b, 0x5f, 0x00, 0x40, 0x00, 0x04, 0x00,
  2892. + 0x40, 0x00, 0x57, 0x70, 0x09, 0x0b, 0x57, 0x00,
  2893. + 0x04, 0x00, 0x0f, 0x20, 0x02, 0xb8, 0x09, 0xfa,
  2894. + 0xea, 0x20, 0xed, 0x42, 0x28, 0x00, 0x09, 0x40,
  2895. + 0x26, 0x00, 0x29, 0x00, 0x08, 0x14, 0x03, 0xe8,
  2896. + 0x20, 0x00, 0x6b, 0x00, 0x08, 0x17, 0x01, 0xda,
  2897. + 0x08, 0x17, 0xea, 0x00, 0x02, 0xb8, 0x02, 0x38,
  2898. + 0x61, 0x00, 0x08, 0x16, 0x01, 0xda, 0x0f, 0x00,
  2899. + 0xfa, 0x10, 0x09, 0x0a, 0xee, 0x00, 0x09, 0x0a,
  2900. + 0xe9, 0x00, 0xe8, 0x04, 0x62, 0x00, 0x0b, 0x00,
  2901. + 0x01, 0xd9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  2902. + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  2903. diff --git a/drivers/dect/coa/sc1442x_firmware.h b/drivers/dect/coa/sc1442x_firmware.h
  2904. new file mode 100644
  2905. index 0000000..8d615bd
  2906. --- /dev/null
  2907. +++ b/drivers/dect/coa/sc1442x_firmware.h
  2908. @@ -0,0 +1,70 @@
  2909. +#ifndef SC1442X_FIRMWARE
  2910. +#define SC1442X_FIRMWARE
  2911. +
  2912. +extern const unsigned char sc1442x_firmware[510];
  2913. +
  2914. +#define DIP_CC_INIT 0x10
  2915. +#define RF_DESC 0x65
  2916. +#define BMC_CTRL 0x69
  2917. +#define BMC_CTRL_MFR_OFF 0x6
  2918. +#define SD_RSSI_OFF 0x0
  2919. +#define SD_CSUM_OFF 0x1
  2920. +#define SD_PREAMBLE_OFF 0x1
  2921. +#define SD_DATA_OFF 0x6
  2922. +#define SlotTable 0x2
  2923. +#define Slot00 0x3
  2924. +#define Slot01 0x5
  2925. +#define Slot02 0x7
  2926. +#define Slot03 0x9
  2927. +#define Slot04 0xB
  2928. +#define Slot05 0xD
  2929. +#define Slot06 0x10
  2930. +#define Slot07 0x12
  2931. +#define Slot08 0x14
  2932. +#define Slot09 0x16
  2933. +#define Slot10 0x18
  2934. +#define Slot11 0x1A
  2935. +#define Slot12 0x1D
  2936. +#define Slot13 0x1F
  2937. +#define Slot14 0x21
  2938. +#define Slot15 0x23
  2939. +#define Slot16 0x25
  2940. +#define Slot17 0x27
  2941. +#define Slot18 0x2A
  2942. +#define Slot19 0x2C
  2943. +#define Slot20 0x2E
  2944. +#define Slot21 0x30
  2945. +#define Slot22 0x32
  2946. +#define Slot23 0x34
  2947. +#define RFStart 0xF8
  2948. +#define RFInit 0xB8
  2949. +#define SyncInit 0xD9
  2950. +#define Sync 0xDA
  2951. +#define SyncLock 0xEA
  2952. +#define SyncLoop 0xEE
  2953. +#define ClockSyncOn 0x86
  2954. +#define ClockSyncOff 0x8E
  2955. +#define ClockAdjust 0x8A
  2956. +#define PSC_ARPD1 0x80
  2957. +#define PSC_S_SYNC 0x40
  2958. +#define PSC_S_SYNC_ON 0x20
  2959. +#define PSC_EOPSM 0x10
  2960. +#define RX_P00 0x38
  2961. +#define RX_P00_Sync 0x3C
  2962. +#define RX_P32U 0x3F
  2963. +#define RX_P32U_Enc 0x3E
  2964. +#define RX_P640j 0x44
  2965. +#define RX_P640j_Enc 0x43
  2966. +#define TX_P00 0x4B
  2967. +#define TX_P32U 0x4F
  2968. +#define TX_P32U_Enc 0x4E
  2969. +#define TX_P640j 0x54
  2970. +#define TX_P640j_Enc 0x53
  2971. +#define DCS_IV 0x70
  2972. +#define DCS_CK 0x78
  2973. +#define DCS_STATE 0x70
  2974. +#define DCS_STATE_SIZE 0xB
  2975. +#define LoadEncKey 0xC7
  2976. +#define LoadEncState 0xD4
  2977. +
  2978. +#endif /* SC1442X_FIRMWARE */
  2979. diff --git a/drivers/dect/vtrx/Kconfig b/drivers/dect/vtrx/Kconfig
  2980. new file mode 100644
  2981. index 0000000..fb86eee
  2982. --- /dev/null
  2983. +++ b/drivers/dect/vtrx/Kconfig
  2984. @@ -0,0 +1,5 @@
  2985. +config DECT_VTRX
  2986. + tristate "DECT virtual transceiver support"
  2987. + depends on DECT
  2988. + help
  2989. + This option enables support for the virtual DECT transceiver.
  2990. diff --git a/drivers/dect/vtrx/Makefile b/drivers/dect/vtrx/Makefile
  2991. new file mode 100644
  2992. index 0000000..08abbf5
  2993. --- /dev/null
  2994. +++ b/drivers/dect/vtrx/Makefile
  2995. @@ -0,0 +1,2 @@
  2996. +obj-$(CONFIG_DECT_VTRX) += dect-vtrx.o
  2997. +dect-vtrx-objs := vtrx.o vtrx-sysfs.o mw_to_dbm.o
  2998. diff --git a/drivers/dect/vtrx/mw_to_dbm.c b/drivers/dect/vtrx/mw_to_dbm.c
  2999. new file mode 100644
  3000. index 0000000..55122a8
  3001. --- /dev/null
  3002. +++ b/drivers/dect/vtrx/mw_to_dbm.c
  3003. @@ -0,0 +1,164 @@
  3004. +/*
  3005. + * DECT virtual transceiver
  3006. + *
  3007. + * Copyright (c) 2010 Patrick McHardy <[email protected]>
  3008. + *
  3009. + * This program is free software; you can redistribute it and/or modify
  3010. + * it under the terms of the GNU General Public License version 2 as
  3011. + * published by the Free Software Foundation.
  3012. + */
  3013. +
  3014. +#include <linux/kernel.h>
  3015. +#include <net/dect/transceiver.h>
  3016. +#include "vtrx.h"
  3017. +
  3018. +static const struct {
  3019. + u64 mw;
  3020. + int dbm;
  3021. +} mw_to_dbm_tbl[] = {
  3022. + { 5ULL, -93 },
  3023. + { 6ULL, -92 },
  3024. + { 7ULL, -91 },
  3025. + { 10ULL, -90 },
  3026. + { 12ULL, -89 },
  3027. + { 15ULL, -88 },
  3028. + { 19ULL, -87 },
  3029. + { 25ULL, -86 },
  3030. + { 31ULL, -85 },
  3031. + { 39ULL, -84 },
  3032. + { 50ULL, -83 },
  3033. + { 63ULL, -82 },
  3034. + { 79ULL, -81 },
  3035. + { 100ULL, -80 },
  3036. + { 125ULL, -79 },
  3037. + { 158ULL, -78 },
  3038. + { 199ULL, -77 },
  3039. + { 251ULL, -76 },
  3040. + { 316ULL, -75 },
  3041. + { 398ULL, -74 },
  3042. + { 501ULL, -73 },
  3043. + { 630ULL, -72 },
  3044. + { 794ULL, -71 },
  3045. + { 1000ULL, -70 },
  3046. + { 1258ULL, -69 },
  3047. + { 1584ULL, -68 },
  3048. + { 1995ULL, -67 },
  3049. + { 2511ULL, -66 },
  3050. + { 3162ULL, -65 },
  3051. + { 3981ULL, -64 },
  3052. + { 5011ULL, -63 },
  3053. + { 6309ULL, -62 },
  3054. + { 7943ULL, -61 },
  3055. + { 10000ULL, -60 },
  3056. + { 12589ULL, -59 },
  3057. + { 15848ULL, -58 },
  3058. + { 19952ULL, -57 },
  3059. + { 25118ULL, -56 },
  3060. + { 31622ULL, -55 },
  3061. + { 39810ULL, -54 },
  3062. + { 50118ULL, -53 },
  3063. + { 63095ULL, -52 },
  3064. + { 79432ULL, -51 },
  3065. + { 100000ULL, -50 },
  3066. + { 125892ULL, -49 },
  3067. + { 158489ULL, -48 },
  3068. + { 199526ULL, -47 },
  3069. + { 251188ULL, -46 },
  3070. + { 316227ULL, -45 },
  3071. + { 398107ULL, -44 },
  3072. + { 501187ULL, -43 },
  3073. + { 630957ULL, -42 },
  3074. + { 794328ULL, -41 },
  3075. + { 1000000ULL, -40 },
  3076. + { 1258925ULL, -39 },
  3077. + { 1584893ULL, -38 },
  3078. + { 1995262ULL, -37 },
  3079. + { 2511886ULL, -36 },
  3080. + { 3162277ULL, -35 },
  3081. + { 3981071ULL, -34 },
  3082. + { 5011872ULL, -33 },
  3083. + { 6309573ULL, -32 },
  3084. + { 7943282ULL, -31 },
  3085. + { 10000000ULL, -30 },
  3086. + { 12589254ULL, -29 },
  3087. + { 15848931ULL, -28 },
  3088. + { 19952623ULL, -27 },
  3089. + { 25118864ULL, -26 },
  3090. + { 31622776ULL, -25 },
  3091. + { 39810717ULL, -24 },
  3092. + { 50118723ULL, -23 },
  3093. + { 63095734ULL, -22 },
  3094. + { 79432823ULL, -21 },
  3095. + { 100000000ULL, -20 },
  3096. + { 125892541ULL, -19 },
  3097. + { 158489319ULL, -18 },
  3098. + { 199526231ULL, -17 },
  3099. + { 251188643ULL, -16 },
  3100. + { 316227766ULL, -15 },
  3101. + { 398107170ULL, -14 },
  3102. + { 501187233ULL, -13 },
  3103. + { 630957344ULL, -12 },
  3104. + { 794328234ULL, -11 },
  3105. + { 1000000000ULL, -10 },
  3106. + { 1258925411ULL, -9 },
  3107. + { 1584893192ULL, -8 },
  3108. + { 1995262314ULL, -7 },
  3109. + { 2511886431ULL, -6 },
  3110. + { 3162277660ULL, -5 },
  3111. + { 3981071705ULL, -4 },
  3112. + { 5011872336ULL, -3 },
  3113. + { 6309573444ULL, -2 },
  3114. + { 7943282347ULL, -1 },
  3115. + { 10000000000ULL, 0 },
  3116. + { 12589254117ULL, 1 },
  3117. + { 15848931924ULL, 2 },
  3118. + { 19952623149ULL, 3 },
  3119. + { 25118864315ULL, 4 },
  3120. + { 31622776601ULL, 5 },
  3121. + { 39810717055ULL, 6 },
  3122. + { 50118723362ULL, 7 },
  3123. + { 63095734448ULL, 8 },
  3124. + { 79432823472ULL, 9 },
  3125. + { 100000000000ULL, 10 },
  3126. + { 125892541179ULL, 11 },
  3127. + { 158489319246ULL, 12 },
  3128. + { 199526231496ULL, 13 },
  3129. + { 251188643150ULL, 14 },
  3130. + { 316227766016ULL, 15 },
  3131. + { 398107170553ULL, 16 },
  3132. + { 501187233627ULL, 17 },
  3133. + { 630957344480ULL, 18 },
  3134. + { 794328234724ULL, 19 },
  3135. + { 1000000000000ULL, 20 },
  3136. + { 1258925411794ULL, 21 },
  3137. + { 1584893192461ULL, 22 },
  3138. + { 1995262314968ULL, 23 },
  3139. + { 2511886431509ULL, 24 },
  3140. +};
  3141. +
  3142. +int dect_mw_to_dbm(u64 mw)
  3143. +{
  3144. + unsigned int min, max, mid;
  3145. + u64 val;
  3146. +
  3147. + min = 0;
  3148. + max = ARRAY_SIZE(mw_to_dbm_tbl) - 1;
  3149. +
  3150. + while (min < max) {
  3151. + mid = min + (max - min) / 2;
  3152. +
  3153. + val = mw_to_dbm_tbl[mid].mw;
  3154. + if (val < mw)
  3155. + min = mid + 1;
  3156. + else
  3157. + max = mid;
  3158. + }
  3159. +
  3160. + if (val > mw) {
  3161. + if (mid == 0)
  3162. + return 0;
  3163. + mid--;
  3164. + }
  3165. +
  3166. + return mw_to_dbm_tbl[mid].dbm;
  3167. +}
  3168. diff --git a/drivers/dect/vtrx/vtrx-sysfs.c b/drivers/dect/vtrx/vtrx-sysfs.c
  3169. new file mode 100644
  3170. index 0000000..c89c85a
  3171. --- /dev/null
  3172. +++ b/drivers/dect/vtrx/vtrx-sysfs.c
  3173. @@ -0,0 +1,230 @@
  3174. +/*
  3175. + * DECT virtual transceiver
  3176. + *
  3177. + * Copyright (c) 2010 Patrick McHardy <[email protected]>
  3178. + *
  3179. + * This program is free software; you can redistribute it and/or modify
  3180. + * it under the terms of the GNU General Public License version 2 as
  3181. + * published by the Free Software Foundation.
  3182. + */
  3183. +
  3184. +#include <linux/kernel.h>
  3185. +#include <linux/stat.h>
  3186. +#include <linux/export.h>
  3187. +#include <net/dect/transceiver.h>
  3188. +#include "vtrx.h"
  3189. +
  3190. +static struct class *dect_class;
  3191. +
  3192. +/*
  3193. + * Transceivers
  3194. + */
  3195. +
  3196. +#define VTRX_ATTR(_name, _mode, _show, _store) \
  3197. + struct device_attribute vtrx_attr_##_name = __ATTR(_name, _mode, _show, _store)
  3198. +
  3199. +#define VTRX_NUMERIC_ATTR(name, field, scale) \
  3200. +static ssize_t vtrx_show_##name(struct device *dev, struct device_attribute *attr, \
  3201. + char *buf) \
  3202. +{ \
  3203. + struct dect_vtrx *vtrx = dev_get_drvdata(dev); \
  3204. + return sprintf(buf, "%llu\n", \
  3205. + (unsigned long long)div64_u64(vtrx->field, scale)); \
  3206. +} \
  3207. + \
  3208. +static ssize_t vtrx_store_##name(struct device *dev, struct device_attribute *attr, \
  3209. + const char *buf, size_t count) \
  3210. +{ \
  3211. + struct dect_vtrx *vtrx = dev_get_drvdata(dev); \
  3212. + char *ptr; \
  3213. + u32 val; \
  3214. + \
  3215. + val = simple_strtoul(buf, &ptr, 10); \
  3216. + if (ptr == buf) \
  3217. + return -EINVAL; \
  3218. + vtrx->field = val * scale; \
  3219. + return count; \
  3220. +} \
  3221. +static VTRX_ATTR(name, S_IRUGO | S_IWUSR, vtrx_show_##name, vtrx_store_##name)
  3222. +
  3223. +VTRX_NUMERIC_ATTR(tx_power, tx_power, DECT_VTRX_POWER_SCALE);
  3224. +VTRX_NUMERIC_ATTR(pos_x, pos_x, 1000);
  3225. +VTRX_NUMERIC_ATTR(pos_y, pos_y, 1000);
  3226. +
  3227. +static ssize_t vtrx_store_remove(struct device *dev, struct device_attribute *attr,
  3228. + const char *buf, size_t count)
  3229. +{
  3230. + struct dect_vtrx *vtrx = dev_get_drvdata(dev);
  3231. +
  3232. + dect_vtrx_free(vtrx);
  3233. + return count;
  3234. +}
  3235. +
  3236. +static VTRX_ATTR(remove, S_IWUSR, NULL, vtrx_store_remove);
  3237. +
  3238. +static struct attribute *vtrx_attrs[] = {
  3239. + &vtrx_attr_tx_power.attr,
  3240. + &vtrx_attr_pos_x.attr,
  3241. + &vtrx_attr_pos_y.attr,
  3242. + &vtrx_attr_remove.attr,
  3243. + NULL
  3244. +};
  3245. +
  3246. +static struct attribute_group vtrx_attr_group = {
  3247. + .attrs = vtrx_attrs,
  3248. +};
  3249. +
  3250. +static const struct attribute_group *vtrx_attr_groups[] = {
  3251. + &vtrx_attr_group,
  3252. + NULL,
  3253. +};
  3254. +
  3255. +static void dect_vtrx_release(struct device *dev)
  3256. +{
  3257. + printk("%s\n", __func__);
  3258. +}
  3259. +
  3260. +static struct device_type dect_vtrx_group = {
  3261. + .name = "vtrx",
  3262. + .groups = vtrx_attr_groups,
  3263. + .release = dect_vtrx_release,
  3264. +};
  3265. +
  3266. +int dect_vtrx_register_sysfs(struct dect_vtrx *vtrx)
  3267. +{
  3268. + struct device *dev = &vtrx->dev;
  3269. +
  3270. + dev->type = &dect_vtrx_group;
  3271. + dev->class = dect_class;
  3272. + dev->parent = &vtrx->group->dev;
  3273. +
  3274. + dev_set_name(dev, "%s", vtrx->trx->name);
  3275. + dev_set_drvdata(dev, vtrx);
  3276. +
  3277. + return device_register(dev);
  3278. +}
  3279. +
  3280. +void dect_vtrx_unregister_sysfs(struct dect_vtrx *vtrx)
  3281. +{
  3282. + device_del(&vtrx->dev);
  3283. +}
  3284. +
  3285. +/*
  3286. + * Groups
  3287. + */
  3288. +
  3289. +#define GROUP_ATTR(_name, _mode, _show, _store) \
  3290. + struct device_attribute group_attr_##_name = __ATTR(_name, _mode, _show, _store)
  3291. +
  3292. +#define GROUP_SHOW(name, field, fmt) \
  3293. +static ssize_t group_show_##name(struct device *dev, struct device_attribute *attr, \
  3294. + char *buf) \
  3295. +{ \
  3296. + struct dect_vtrx_group *group = dev_get_drvdata(dev); \
  3297. + return sprintf(buf, fmt, group->field); \
  3298. +} \
  3299. + \
  3300. +static ssize_t group_store_##name(struct device *dev, struct device_attribute *attr, \
  3301. + const char *buf, size_t count) \
  3302. +{ \
  3303. + struct dect_vtrx_group *group = dev_get_drvdata(dev); \
  3304. + char *ptr; \
  3305. + u32 val; \
  3306. + \
  3307. + val = simple_strtoul(buf, &ptr, 10); \
  3308. + if (ptr == buf) \
  3309. + return -EINVAL; \
  3310. + group->field = val; \
  3311. + return count; \
  3312. +} \
  3313. +static GROUP_ATTR(name, S_IRUGO | S_IWUSR, group_show_##name, group_store_##name)
  3314. +
  3315. +static ssize_t group_store_new(struct device *dev, struct device_attribute *attr,
  3316. + const char *buf, size_t count)
  3317. +{
  3318. + struct dect_vtrx_group *group = dev_get_drvdata(dev);
  3319. + int err;
  3320. +
  3321. + err = dect_vtrx_init(group);
  3322. + return err ? err : count;
  3323. +}
  3324. +
  3325. +static GROUP_ATTR(new_trx, S_IWUSR, NULL, group_store_new);
  3326. +
  3327. +static struct attribute *group_attrs[] = {
  3328. + &group_attr_new_trx.attr,
  3329. + NULL
  3330. +};
  3331. +
  3332. +static struct attribute_group group_attr_group = {
  3333. + .attrs = group_attrs,
  3334. +};
  3335. +
  3336. +static const struct attribute_group *group_attr_groups[] = {
  3337. + &group_attr_group,
  3338. + NULL,
  3339. +};
  3340. +
  3341. +static void dect_vtrx_group_release(struct device *dev)
  3342. +{
  3343. + printk("%s\n", __func__);
  3344. +}
  3345. +
  3346. +static struct device_type dect_vtrx_group_group = {
  3347. + .name = "vtrx-group",
  3348. + .groups = group_attr_groups,
  3349. + .release = dect_vtrx_group_release,
  3350. +};
  3351. +
  3352. +int dect_vtrx_group_register_sysfs(struct dect_vtrx_group *group)
  3353. +{
  3354. + struct device *dev = &group->dev;
  3355. +
  3356. + dev->type = &dect_vtrx_group_group;
  3357. + dev->class = dect_class;
  3358. + dev->parent = NULL;
  3359. +
  3360. + dev_set_name(dev, "%s", group->name);
  3361. + dev_set_drvdata(dev, group);
  3362. +
  3363. + return device_register(dev);
  3364. +}
  3365. +
  3366. +static ssize_t store_new_group(struct class *dev, struct class_attribute *attr,
  3367. + const char *buf, size_t count)
  3368. +{
  3369. + char name[16];
  3370. +
  3371. + sscanf(buf, "%16s", name);
  3372. + if (!dect_vtrx_group_init(name))
  3373. + return -ENOMEM;
  3374. + return count;
  3375. +}
  3376. +
  3377. +static CLASS_ATTR(new_group, S_IWUSR, NULL, store_new_group);
  3378. +
  3379. +void dect_vtrx_group_unregister_sysfs(struct dect_vtrx_group *group)
  3380. +{
  3381. + device_del(&group->dev);
  3382. +}
  3383. +
  3384. +int dect_vtrx_sysfs_init(void)
  3385. +{
  3386. + int err;
  3387. +
  3388. + dect_class = class_create(THIS_MODULE, "dect");
  3389. + if (dect_class == NULL)
  3390. + return -ENOMEM;
  3391. +
  3392. + err = class_create_file(dect_class, &class_attr_new_group);
  3393. + if (err < 0)
  3394. + class_destroy(dect_class);
  3395. +
  3396. + return err;
  3397. +}
  3398. +
  3399. +void dect_vtrx_sysfs_exit(void)
  3400. +{
  3401. + class_remove_file(dect_class, &class_attr_new_group);
  3402. + class_destroy(dect_class);
  3403. +}
  3404. diff --git a/drivers/dect/vtrx/vtrx.c b/drivers/dect/vtrx/vtrx.c
  3405. new file mode 100644
  3406. index 0000000..d6a9084
  3407. --- /dev/null
  3408. +++ b/drivers/dect/vtrx/vtrx.c
  3409. @@ -0,0 +1,397 @@
  3410. +/*
  3411. + * DECT virtual transceiver
  3412. + *
  3413. + * Copyright (c) 2010 Patrick McHardy <[email protected]>
  3414. + *
  3415. + * This program is free software; you can redistribute it and/or modify
  3416. + * it under the terms of the GNU General Public License version 2 as
  3417. + * published by the Free Software Foundation.
  3418. + */
  3419. +
  3420. +#define DEBUG
  3421. +#include <linux/kernel.h>
  3422. +#include <linux/module.h>
  3423. +#include <linux/init.h>
  3424. +#include <linux/kobject.h>
  3425. +#include <linux/hrtimer.h>
  3426. +#include <linux/skbuff.h>
  3427. +#include <net/dect/transceiver.h>
  3428. +#include "vtrx.h"
  3429. +
  3430. +#define vtrx_debug(vtrx, fmt, args...) \
  3431. + pr_debug("vtrx %s: " fmt, (vtrx)->trx->name, ## args)
  3432. +
  3433. +#define DECT_SLOTS_PER_SECOND (DECT_FRAMES_PER_SECOND * DECT_FRAME_SIZE)
  3434. +#define DECT_VTRX_RATE (NSEC_PER_SEC / DECT_SLOTS_PER_SECOND)
  3435. +#define DECT_VTRX_DEFAULT_TRX 2
  3436. +
  3437. +#define DECT_WAVELEN_SCALE 13
  3438. +#define DECT_WAVELEN 160 /* mm */
  3439. +
  3440. +struct dect_skb_vtrx_cb {
  3441. + struct dect_vtrx *vtrx;
  3442. + u8 rssi;
  3443. + u8 carrier;
  3444. +};
  3445. +
  3446. +static LIST_HEAD(vtrx_groups);
  3447. +
  3448. +static inline struct dect_skb_vtrx_cb *DECT_VTRX_CB(const struct sk_buff *skb)
  3449. +{
  3450. + BUILD_BUG_ON(sizeof(struct dect_skb_vtrx_cb) > sizeof(skb->cb));
  3451. + return (struct dect_skb_vtrx_cb *)skb->cb;
  3452. +}
  3453. +
  3454. +static unsigned int dect_vtrx_distance(const struct dect_vtrx *vtrx1,
  3455. + const struct dect_vtrx *vtrx2)
  3456. +{
  3457. + int dx, dy;
  3458. +
  3459. + dx = vtrx1->pos_x - vtrx2->pos_x;
  3460. + dy = vtrx1->pos_y - vtrx2->pos_y;
  3461. +
  3462. + return int_sqrt(dx * dx + dy * dy);
  3463. +}
  3464. +
  3465. +static u8 dect_vtrx_receive_rssi(const struct dect_vtrx *rx_vtrx,
  3466. + const struct sk_buff *skb)
  3467. +{
  3468. + const struct dect_vtrx *tx_vtrx = DECT_VTRX_CB(skb)->vtrx;
  3469. + unsigned int distance;
  3470. + u64 rx_power, tmp;
  3471. + int dbm = 0;
  3472. +
  3473. + distance = dect_vtrx_distance(rx_vtrx, tx_vtrx);
  3474. + if (distance == 0)
  3475. + goto out;
  3476. +
  3477. + tmp = 1000 * (DECT_WAVELEN << DECT_WAVELEN_SCALE) / (4 * 3141 * distance);
  3478. + rx_power = (tx_vtrx->tx_power * tmp * tmp) >> (2 * DECT_WAVELEN_SCALE);
  3479. + dbm = dect_mw_to_dbm(rx_power);
  3480. +out:
  3481. + if (dbm > -33)
  3482. + dbm = -33;
  3483. +
  3484. + return dect_dbm_to_rssi(dbm);
  3485. +}
  3486. +
  3487. +static void dect_vtrx_process_slot(struct dect_vtrx_group *group,
  3488. + struct dect_vtrx *vtrx)
  3489. +{
  3490. + struct dect_transceiver_event *event;
  3491. + struct dect_transceiver_slot *ts;
  3492. + struct dect_transceiver *trx = vtrx->trx;
  3493. + struct sk_buff *skb, *best;
  3494. + u8 slot = group->slot, rcvslot;
  3495. + u8 rssi, best_rssi = 0;
  3496. +
  3497. + event = dect_transceiver_event(trx, slot % 12, slot);
  3498. + if (event == NULL)
  3499. + return;
  3500. +
  3501. + if (trx->state == DECT_TRANSCEIVER_UNLOCKED ||
  3502. + trx->state == DECT_TRANSCEIVER_LOCK_PENDING)
  3503. + rcvslot = DECT_SCAN_SLOT;
  3504. + else
  3505. + rcvslot = slot;
  3506. +
  3507. + rssi = dect_dbm_to_rssi(-80);
  3508. + best = NULL;
  3509. +
  3510. + ts = &trx->slots[rcvslot];
  3511. + if (ts->state != DECT_SLOT_RX &&
  3512. + ts->state != DECT_SLOT_SCANNING)
  3513. + goto queue;
  3514. +
  3515. + skb_queue_walk(&group->txq[slot], skb) {
  3516. + if (DECT_VTRX_CB(skb)->carrier != ts->chd.carrier)
  3517. + continue;
  3518. +
  3519. + rssi = dect_vtrx_receive_rssi(vtrx, skb);
  3520. + if (best == NULL || rssi > best_rssi) {
  3521. + best = skb;
  3522. + best_rssi = rssi;
  3523. + }
  3524. + }
  3525. +
  3526. + if (best == NULL)
  3527. + goto rssi;
  3528. + rssi = best_rssi;
  3529. +
  3530. + skb = skb_clone(best, GFP_ATOMIC);
  3531. + if (skb == NULL)
  3532. + goto rssi;
  3533. +
  3534. + DECT_TRX_CB(skb)->trx = trx;
  3535. + DECT_TRX_CB(skb)->slot = rcvslot;
  3536. + DECT_TRX_CB(skb)->csum = DECT_CHECKSUM_A_CRC_OK | DECT_CHECKSUM_X_CRC_OK;
  3537. + DECT_TRX_CB(skb)->rssi = rssi;
  3538. + __skb_queue_tail(&event->rx_queue, skb);
  3539. +
  3540. + ts->rx_bytes += skb->len;
  3541. + ts->rx_packets++;
  3542. +rssi:
  3543. + ts->rssi = dect_average_rssi(ts->rssi, rssi);
  3544. + dect_transceiver_record_rssi(event, rcvslot, rssi);
  3545. +queue:
  3546. + if (rcvslot != slot && best == NULL)
  3547. + dect_release_transceiver_event(event);
  3548. + else
  3549. + dect_transceiver_queue_event(trx, event);
  3550. +}
  3551. +
  3552. +static enum hrtimer_restart dect_vtrx_timer(struct hrtimer *timer)
  3553. +{
  3554. + struct dect_vtrx_group *group = container_of(timer, struct dect_vtrx_group, timer);
  3555. + struct dect_vtrx *vtrx;
  3556. + ktime_t time;
  3557. +
  3558. + list_for_each_entry(vtrx, &group->act_list, list)
  3559. + dect_vtrx_process_slot(group, vtrx);
  3560. +
  3561. + skb_queue_purge(&group->txq[group->slot]);
  3562. + group->slot = dect_next_slotnum(group->slot);
  3563. +
  3564. + time = ktime_set(0, DECT_VTRX_RATE);
  3565. + hrtimer_forward(timer, hrtimer_cb_get_time(timer), time);
  3566. +
  3567. + return HRTIMER_RESTART;
  3568. +}
  3569. +
  3570. +/*
  3571. + * Transceiver operations
  3572. + */
  3573. +
  3574. +static void dect_vtrx_enable(const struct dect_transceiver *trx)
  3575. +{
  3576. + struct dect_vtrx *vtrx = dect_transceiver_priv(trx);
  3577. + struct dect_vtrx_group *group = vtrx->group;
  3578. + ktime_t time;
  3579. +
  3580. + vtrx_debug(vtrx, "enable");
  3581. + if (list_empty(&group->act_list)) {
  3582. + time = ktime_set(0, DECT_VTRX_RATE);
  3583. + hrtimer_start(&group->timer, time, HRTIMER_MODE_ABS);
  3584. + }
  3585. + list_move_tail(&vtrx->list, &group->act_list);
  3586. +}
  3587. +
  3588. +static void dect_vtrx_disable(const struct dect_transceiver *trx)
  3589. +{
  3590. + struct dect_vtrx *vtrx = dect_transceiver_priv(trx);
  3591. + struct dect_vtrx_group *group = vtrx->group;
  3592. +
  3593. + vtrx_debug(vtrx, "disable");
  3594. + list_move_tail(&vtrx->list, &group->trx_list);
  3595. + if (list_empty(&group->act_list))
  3596. + hrtimer_cancel(&group->timer);
  3597. +}
  3598. +
  3599. +static void dect_vtrx_confirm(const struct dect_transceiver *trx)
  3600. +{
  3601. + struct dect_vtrx *vtrx = dect_transceiver_priv(trx);
  3602. +
  3603. + vtrx_debug(vtrx, "confirm");
  3604. +}
  3605. +
  3606. +static void dect_vtrx_unlock(const struct dect_transceiver *trx)
  3607. +{
  3608. + struct dect_vtrx *vtrx = dect_transceiver_priv(trx);
  3609. +
  3610. + vtrx_debug(vtrx, "unlock");
  3611. +}
  3612. +
  3613. +static void dect_vtrx_lock(const struct dect_transceiver *trx, u8 slot)
  3614. +{
  3615. + struct dect_vtrx *vtrx = dect_transceiver_priv(trx);
  3616. +
  3617. + vtrx_debug(vtrx, "lock");
  3618. +}
  3619. +
  3620. +static void dect_vtrx_set_mode(const struct dect_transceiver *trx,
  3621. + const struct dect_channel_desc *chd,
  3622. + enum dect_slot_states mode)
  3623. +{
  3624. + struct dect_vtrx *vtrx = dect_transceiver_priv(trx);
  3625. +
  3626. + vtrx_debug(vtrx, "set_mode: slot: %u mode: %u",
  3627. + chd->slot, mode);
  3628. +}
  3629. +
  3630. +static void dect_vtrx_set_carrier(const struct dect_transceiver *trx,
  3631. + u8 slot, u8 carrier)
  3632. +{
  3633. + struct dect_vtrx *vtrx = dect_transceiver_priv(trx);
  3634. +
  3635. + vtrx_debug(vtrx, "set carrier: slot: %u carrier: %u\n",
  3636. + slot, carrier);
  3637. +}
  3638. +
  3639. +static u64 dect_vtrx_set_band(const struct dect_transceiver *trx,
  3640. + const struct dect_band *band)
  3641. +{
  3642. + struct dect_vtrx *vtrx = dect_transceiver_priv(trx);
  3643. +
  3644. + vtrx_debug(vtrx, "set band: %u\n", band->band);
  3645. + return band->carriers;
  3646. +}
  3647. +
  3648. +static void dect_vtrx_tx(const struct dect_transceiver *trx, struct sk_buff *skb)
  3649. +{
  3650. + struct dect_vtrx *vtrx = dect_transceiver_priv(trx);
  3651. + struct dect_vtrx_group *group = vtrx->group;
  3652. + u8 slot = DECT_TRX_CB(skb)->slot;
  3653. +
  3654. + vtrx_debug(vtrx, "vtrx tx: slot: %u skb: %p\n", slot, skb);
  3655. + DECT_VTRX_CB(skb)->vtrx = vtrx;
  3656. + DECT_VTRX_CB(skb)->rssi = vtrx->tx_power;
  3657. + DECT_VTRX_CB(skb)->carrier = trx->slots[slot].chd.carrier;
  3658. + skb_queue_tail(&group->txq[slot], skb);
  3659. +}
  3660. +
  3661. +static const struct dect_transceiver_ops vtrx_transceiver_ops = {
  3662. + .name = "vtrx",
  3663. + .eventrate = 1,
  3664. + .latency = 1,
  3665. + .enable = dect_vtrx_enable,
  3666. + .disable = dect_vtrx_disable,
  3667. + .confirm = dect_vtrx_confirm,
  3668. + .unlock = dect_vtrx_unlock,
  3669. + .lock = dect_vtrx_lock,
  3670. + .set_mode = dect_vtrx_set_mode,
  3671. + .set_carrier = dect_vtrx_set_carrier,
  3672. + .set_band = dect_vtrx_set_band,
  3673. + .tx = dect_vtrx_tx,
  3674. + .destructor = dect_transceiver_free,
  3675. +};
  3676. +
  3677. +int dect_vtrx_init(struct dect_vtrx_group *group)
  3678. +{
  3679. + struct dect_transceiver *trx;
  3680. + struct dect_vtrx *vtrx;
  3681. + int err;
  3682. +
  3683. + trx = dect_transceiver_alloc(&vtrx_transceiver_ops, sizeof(*vtrx));
  3684. + if (trx == NULL)
  3685. + return -ENOMEM;
  3686. +
  3687. + err = dect_register_transceiver(trx);
  3688. + if (err < 0)
  3689. + goto err1;
  3690. +
  3691. + vtrx = dect_transceiver_priv(trx);
  3692. + vtrx->group = group;
  3693. + vtrx->trx = trx;
  3694. + vtrx->tx_power = 2 * DECT_VTRX_POWER_SCALE;
  3695. + list_add_tail(&vtrx->list, &group->trx_list);
  3696. +
  3697. + dect_vtrx_register_sysfs(vtrx);
  3698. + return 0;
  3699. +
  3700. +err1:
  3701. + dect_transceiver_free(trx);
  3702. + return err;
  3703. +}
  3704. +
  3705. +void dect_vtrx_free(struct dect_vtrx *vtrx)
  3706. +{
  3707. + dect_vtrx_unregister_sysfs(vtrx);
  3708. + dect_unregister_transceiver(vtrx->trx);
  3709. +}
  3710. +
  3711. +struct dect_vtrx_group *dect_vtrx_group_init(const char *name)
  3712. +{
  3713. + struct dect_vtrx_group *group;
  3714. + unsigned int i;
  3715. + int err;
  3716. +
  3717. + group = kzalloc(sizeof(*group), GFP_KERNEL);
  3718. + if (group == NULL)
  3719. + goto err1;
  3720. +
  3721. + strlcpy(group->name, name, sizeof(group->name));
  3722. + INIT_LIST_HEAD(&group->trx_list);
  3723. + INIT_LIST_HEAD(&group->act_list);
  3724. + hrtimer_init(&group->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
  3725. + group->timer.function = dect_vtrx_timer;
  3726. +
  3727. + for (i = 0; i < ARRAY_SIZE(group->txq); i++)
  3728. + skb_queue_head_init(&group->txq[i]);
  3729. +
  3730. + err = dect_vtrx_group_register_sysfs(group);
  3731. + if (err < 0)
  3732. + goto err2;
  3733. +
  3734. + list_add_tail(&group->list, &vtrx_groups);
  3735. + return group;
  3736. +
  3737. +err2:
  3738. + kfree(group);
  3739. +err1:
  3740. + return NULL;
  3741. +}
  3742. +
  3743. +void dect_vtrx_group_free(struct dect_vtrx_group *group)
  3744. +{
  3745. + struct dect_vtrx *vtrx, *next;
  3746. + unsigned int i;
  3747. +
  3748. + list_for_each_entry_safe(vtrx, next, &group->act_list, list)
  3749. + dect_vtrx_free(vtrx);
  3750. + list_for_each_entry_safe(vtrx, next, &group->trx_list, list)
  3751. + dect_vtrx_free(vtrx);
  3752. +
  3753. + dect_vtrx_group_unregister_sysfs(group);
  3754. +
  3755. + for (i = 0; i < ARRAY_SIZE(group->txq); i++)
  3756. + __skb_queue_purge(&group->txq[i]);
  3757. +
  3758. + kfree(group);
  3759. +}
  3760. +
  3761. +static int __init vtrx_init(void)
  3762. +{
  3763. + struct dect_vtrx_group *group;
  3764. + unsigned int i;
  3765. + int err;
  3766. +
  3767. + err = dect_vtrx_sysfs_init();
  3768. + if (err < 0)
  3769. + goto err1;
  3770. +
  3771. + group = dect_vtrx_group_init("group-1");
  3772. + if (group == NULL) {
  3773. + err = -ENOMEM;
  3774. + goto err2;
  3775. + }
  3776. +
  3777. + for (i = 0; i < DECT_VTRX_DEFAULT_TRX; i++) {
  3778. + err = dect_vtrx_init(group);
  3779. + if (err < 0)
  3780. + goto err3;
  3781. + }
  3782. +
  3783. + return 0;
  3784. +
  3785. +err3:
  3786. + dect_vtrx_group_free(group);
  3787. +err2:
  3788. + dect_vtrx_sysfs_exit();
  3789. +err1:
  3790. + return err;
  3791. +}
  3792. +
  3793. +static void __exit vtrx_exit(void)
  3794. +{
  3795. + struct dect_vtrx_group *group, *next;
  3796. +
  3797. + list_for_each_entry_safe(group, next, &vtrx_groups, list)
  3798. + dect_vtrx_group_free(group);
  3799. +
  3800. + dect_vtrx_sysfs_exit();
  3801. +}
  3802. +
  3803. +module_init(vtrx_init);
  3804. +module_exit(vtrx_exit);
  3805. +
  3806. +MODULE_LICENSE("GPL");
  3807. diff --git a/drivers/dect/vtrx/vtrx.h b/drivers/dect/vtrx/vtrx.h
  3808. new file mode 100644
  3809. index 0000000..67aaba6
  3810. --- /dev/null
  3811. +++ b/drivers/dect/vtrx/vtrx.h
  3812. @@ -0,0 +1,42 @@
  3813. +#ifndef _DECT_VTRX_H
  3814. +#define _DECT_VTRX_H
  3815. +
  3816. +struct dect_vtrx_group {
  3817. + struct list_head list;
  3818. + struct device dev;
  3819. + char name[16];
  3820. + struct hrtimer timer;
  3821. + struct list_head trx_list;
  3822. + struct list_head act_list;
  3823. + struct sk_buff_head txq[DECT_FRAME_SIZE];
  3824. + unsigned int slot;
  3825. +};
  3826. +
  3827. +struct dect_vtrx {
  3828. + struct list_head list;
  3829. + struct device dev;
  3830. + struct dect_vtrx_group *group;
  3831. + struct dect_transceiver *trx;
  3832. + u64 tx_power;
  3833. + unsigned int pos_x;
  3834. + unsigned int pos_y;
  3835. +};
  3836. +
  3837. +extern struct dect_vtrx_group *dect_vtrx_group_init(const char *name);
  3838. +extern void dect_vtrx_group_free(struct dect_vtrx_group *group);
  3839. +extern int dect_vtrx_group_register_sysfs(struct dect_vtrx_group *group);
  3840. +extern void dect_vtrx_group_unregister_sysfs(struct dect_vtrx_group *group);
  3841. +
  3842. +extern int dect_vtrx_register_sysfs(struct dect_vtrx *vtrx);
  3843. +extern void dect_vtrx_unregister_sysfs(struct dect_vtrx *vtrx);
  3844. +extern int dect_vtrx_init(struct dect_vtrx_group *group);
  3845. +extern void dect_vtrx_free(struct dect_vtrx *vtrx);
  3846. +
  3847. +extern int dect_vtrx_sysfs_init(void);
  3848. +extern void dect_vtrx_sysfs_exit(void);
  3849. +
  3850. +#define DECT_VTRX_POWER_SCALE 10000000000ULL
  3851. +
  3852. +extern int dect_mw_to_dbm(u64 mw);
  3853. +
  3854. +#endif /* _DECT_VTRX_H */
  3855. diff --git a/include/linux/netlink.h b/include/linux/netlink.h
  3856. index da14ab6..18eed27 100644
  3857. --- a/include/linux/netlink.h
  3858. +++ b/include/linux/netlink.h
  3859. @@ -1,7 +1,6 @@
  3860. #ifndef __LINUX_NETLINK_H
  3861. #define __LINUX_NETLINK_H
  3863. -
  3864. #include <linux/capability.h>
  3865. #include <linux/skbuff.h>
  3866. #include <linux/export.h>
  3867. diff --git a/include/linux/socket.h b/include/linux/socket.h
  3868. index b5cc5a6..5b3b3c3 100644
  3869. --- a/include/linux/socket.h
  3870. +++ b/include/linux/socket.h
  3871. @@ -203,7 +203,8 @@ struct ucred {
  3872. #define AF_KCM 41 /* Kernel Connection Multiplexor*/
  3873. #define AF_QIPCRTR 42 /* Qualcomm IPC Router */
  3875. -#define AF_MAX 43 /* For now.. */
  3876. +#define AF_DECT 43 /* DECT sockets*/
  3877. +#define AF_MAX 44 /* For now.. */
  3879. /* Protocol families, same as address families. */
  3880. #define PF_UNSPEC AF_UNSPEC
  3881. @@ -251,6 +252,7 @@ struct ucred {
  3882. #define PF_VSOCK AF_VSOCK
  3883. #define PF_KCM AF_KCM
  3884. #define PF_QIPCRTR AF_QIPCRTR
  3885. +#define PF_DECT AF_DECT
  3886. #define PF_MAX AF_MAX
  3888. /* Maximum queue length specifiable by listen. */
  3889. @@ -329,6 +331,7 @@ struct ucred {
  3890. #define SOL_ALG 279
  3891. #define SOL_NFC 280
  3892. #define SOL_KCM 281
  3893. +#define SOL_DECT 282
  3895. /* IPX options */
  3896. #define IPX_TYPE 1
  3897. diff --git a/include/net/dect/ccp.h b/include/net/dect/ccp.h
  3898. new file mode 100644
  3899. index 0000000..5234c7d
  3900. --- /dev/null
  3901. +++ b/include/net/dect/ccp.h
  3902. @@ -0,0 +1,110 @@
  3903. +/*
  3904. + * DECT MAC Layer - Cell Control Protocol (CCP)
  3905. + *
  3906. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  3907. + */
  3908. +
  3909. +#ifndef _NET_DECT_CCP
  3910. +#define _NET_DECT_CCP
  3911. +
  3912. +#define DECT_CCP_TIPC_TYPE TIPC_RESERVED_TYPES
  3913. +#define DECT_CCP_CELL_PORT 1000
  3914. +#define DECT_CCP_CLUSTER_PORT_BASE 1000
  3915. +
  3916. +enum dect_ccp_primitives {
  3917. + /* CCF -> CSF */
  3918. + DECT_CCP_SET_MODE,
  3919. + DECT_CCP_SCAN,
  3920. + DECT_CCP_ENABLE,
  3921. + DECT_CCP_PRELOAD,
  3922. + DECT_CCP_MAC_INFO_IND,
  3923. + DECT_CCP_PAGE_REQ,
  3924. + DECT_CCP_TBC_ESTABLISH_REQ,
  3925. + DECT_CCP_TBC_ESTABLISH_RES,
  3926. + DECT_CCP_TBC_DATA_REQ,
  3927. + DECT_CCP_TBC_DIS_REQ,
  3928. + DECT_CCP_TBC_ENC_KEY_REQ,
  3929. + DECT_CCP_TBC_ENC_EKS_REQ,
  3930. + /* CSF -> CCF */
  3931. + DECT_CCP_TBC_ESTABLISH_IND,
  3932. + DECT_CCP_TBC_ESTABLISH_CFM,
  3933. + DECT_CCP_TBC_EVENT_IND,
  3934. + DECT_CCP_TBC_DATA_IND,
  3935. + DECT_CCP_TBC_DIS_IND,
  3936. +};
  3937. +
  3938. +struct dect_ccp_msg_hdr {
  3939. + u8 primitive;
  3940. +} __attribute__((packed));
  3941. +
  3942. +struct dect_ccp_ari {
  3943. + __be64 ari;
  3944. +};
  3945. +
  3946. +struct dect_ccp_mode_msg {
  3947. + u8 mode;
  3948. +} __attribute__((packed));
  3949. +
  3950. +struct dect_ccp_scan_msg {
  3951. + __be64 ari;
  3952. + __be64 ari_mask;
  3953. +} __attribute__((packed));
  3954. +
  3955. +struct dect_ccp_sysinfo_msg {
  3956. + __be64 pari;
  3957. + __be64 sari[DECT_SARI_CYCLE_MAX];
  3958. + __be64 fpc;
  3959. + __be64 hlc;
  3960. + __be64 efpc;
  3961. + __be32 mfn;
  3962. + u8 num_saris;
  3963. + u8 rpn;
  3964. +} __attribute__((packed));
  3965. +
  3966. +struct dect_ccp_page_msg {
  3967. + u8 fast_page;
  3968. + u8 long_page;
  3969. +} __attribute__((packed));
  3970. +
  3971. +struct dect_ccp_tbc_msg {
  3972. + __be32 tbei;
  3973. + __be32 pmid;
  3974. + __be64 ari;
  3975. + u8 ecn;
  3976. + u8 data;
  3977. +} __attribute__((packed));
  3978. +
  3979. +struct dect_ccp_enc_key_msg {
  3980. + __be64 key;
  3981. +} __attribute__((packed));
  3982. +
  3983. +struct dect_ccp_data_msg {
  3984. + u8 channel;
  3985. + u8 data[];
  3986. +} __attribute__((packed));
  3987. +
  3988. +#ifdef CONFIG_DECT_CCP
  3989. +extern int dect_ccp_cluster_init(struct dect_cluster *cl);
  3990. +extern void dect_ccp_cluster_shutdown(struct dect_cluster *cl);
  3991. +
  3992. +extern struct dect_cluster_handle *dect_ccp_cell_init(struct dect_cell *cell,
  3993. + u8 clindex);
  3994. +#else
  3995. +static inline int dect_ccp_cluster_init(struct dect_cluster *cl)
  3996. +{
  3997. + return 0;
  3998. +}
  3999. +
  4000. +static inline void dect_ccp_cluster_shutdown(struct dect_cluster *cl)
  4001. +{
  4002. + return;
  4003. +}
  4004. +
  4005. +static inline struct dect_cluster_handle *
  4006. +dect_ccp_cell_init(struct dect_cell *cell, u8 clindex)
  4007. +{
  4008. + return ERR_PTR(-EOPNOTSUPP);
  4009. +}
  4010. +#endif
  4011. +
  4012. +#endif /* _NET_DECT_CPP */
  4013. diff --git a/include/net/dect/dect.h b/include/net/dect/dect.h
  4014. new file mode 100644
  4015. index 0000000..5e245c8
  4016. --- /dev/null
  4017. +++ b/include/net/dect/dect.h
  4018. @@ -0,0 +1,319 @@
  4019. +#ifndef _NET_DECT_DECT_H
  4020. +#define _NET_DECT_DECT_H
  4021. +
  4022. +#define DECT_FRAMES_PER_MULTIFRAME 16
  4023. +
  4024. +static inline u8 dect_next_framenum(u8 framenum)
  4025. +{
  4026. + if (++framenum == DECT_FRAMES_PER_MULTIFRAME)
  4027. + framenum = 0;
  4028. + return framenum;
  4029. +}
  4030. +
  4031. +static inline u8 dect_framenum_add(u8 f1, u8 f2)
  4032. +{
  4033. + return (f1 + f2) % DECT_FRAMES_PER_MULTIFRAME;
  4034. +}
  4035. +
  4036. +#define DECT_MULTIFRAME_MASK 0x00ffffff
  4037. +
  4038. +static inline u32 dect_next_mfn(u32 mfn)
  4039. +{
  4040. + if (++mfn == (1 << 24) - 1)
  4041. + mfn = 0;
  4042. + return mfn;
  4043. +}
  4044. +
  4045. +static inline u32 dect_mfn_add(u32 mfn1, u32 mfn2)
  4046. +{
  4047. + return (mfn1 + mfn2) & DECT_MULTIFRAME_MASK;
  4048. +}
  4049. +
  4050. +/* Compare multiframe numbers, considering overflows */
  4051. +static inline bool dect_mfn_before(u32 mfn1, u32 mfn2)
  4052. +{
  4053. + return (s32)((mfn2 << 8) - (mfn1 << 8)) > 0;
  4054. +}
  4055. +
  4056. +static inline bool dect_mfn_after(u32 mfn1, u32 mfn2)
  4057. +{
  4058. + return dect_mfn_before(mfn2, mfn1);
  4059. +}
  4060. +
  4061. +#include <linux/list.h>
  4062. +
  4063. +/**
  4064. + * enum dect_timer_bases - timer bases for DECT timers
  4065. + *
  4066. + * @DECT_TIMER_RX: receive time base
  4067. + * @DECT_TIMER_TX: send time base
  4068. + */
  4069. +enum dect_timer_bases {
  4070. + DECT_TIMER_RX,
  4071. + DECT_TIMER_TX,
  4072. + __DECT_TIMER_BASE_MAX
  4073. +};
  4074. +#define DECT_TIMER_BASE_MAX (__DECT_TIMER_BASE_MAX - 1)
  4075. +
  4076. +/**
  4077. + * struct dect_timer_base - timer base
  4078. + *
  4079. + * @timers: list of active timers
  4080. + * @slot: slot position
  4081. + * @framenum: frame number
  4082. + * @mfn: multiframe number
  4083. + */
  4084. +struct dect_timer_base {
  4085. + struct list_head timers;
  4086. + u8 base;
  4087. + u8 slot;
  4088. + u8 framenum;
  4089. + u32 mfn;
  4090. +};
  4091. +
  4092. +static inline void dect_timer_base_init(struct dect_timer_base base[],
  4093. + enum dect_timer_bases b)
  4094. +{
  4095. + INIT_LIST_HEAD(&base[b].timers);
  4096. + base->base = b;
  4097. +}
  4098. +
  4099. +static inline u8 __dect_slotnum(const struct dect_timer_base *base)
  4100. +{
  4101. + return base->slot;
  4102. +}
  4103. +
  4104. +static inline u8 __dect_framenum(const struct dect_timer_base *base)
  4105. +{
  4106. + return base->framenum;
  4107. +}
  4108. +
  4109. +static inline u32 __dect_mfn(const struct dect_timer_base *base)
  4110. +{
  4111. + return base->mfn;
  4112. +}
  4113. +
  4114. +extern void __dect_run_timers(const char *name, struct dect_timer_base *base);
  4115. +
  4116. +/**
  4117. + * struct dect_timer - DECT TDMA frame timer
  4118. + *
  4119. + * @list: timer list node
  4120. + * @base: timer base
  4121. + * @mfn: expiration time: multiframe number
  4122. + * @frame: expiration time: frame number
  4123. + * @slot: expiration time: slot number
  4124. + * @func: timer function
  4125. + * @data: timer data
  4126. + */
  4127. +struct dect_cell;
  4128. +struct dect_cluster;
  4129. +
  4130. +struct dect_timer {
  4131. + struct list_head list;
  4132. +
  4133. + enum dect_timer_bases base;
  4134. + u32 mfn;
  4135. + u8 frame;
  4136. + u8 slot;
  4137. +
  4138. + union {
  4139. + void (*cell)(struct dect_cell *, void *);
  4140. + void (*cluster)(struct dect_cluster *, void *);
  4141. + void (*cb)(void *, void *);
  4142. + } cb;
  4143. + union {
  4144. + struct dect_cell *cell;
  4145. + struct dect_cluster *cluster;
  4146. + void *obj;
  4147. + };
  4148. + void *data;
  4149. +};
  4150. +
  4151. +static inline void dect_timer_init(struct dect_timer *timer)
  4152. +{
  4153. + INIT_LIST_HEAD(&timer->list);
  4154. +}
  4155. +
  4156. +static inline void dect_timer_del(struct dect_timer *timer)
  4157. +{
  4158. + list_del_init(&timer->list);
  4159. +}
  4160. +
  4161. +extern void __dect_timer_add(const char *name, struct dect_timer_base *base,
  4162. + struct dect_timer *timer, u32 frame, u8 slot);
  4163. +
  4164. +#include <linux/dect.h>
  4165. +#include <net/dect/identities.h>
  4166. +#include <net/dect/mac_ccf.h>
  4167. +#include <net/dect/dlc.h>
  4168. +
  4169. +extern void __acquires(dect_cfg_mutex) dect_lock(void);
  4170. +extern void __releases(dect_cfg_mutex) dect_unlock(void);
  4171. +
  4172. +/**
  4173. + * struct dect_cluster - DECT cluster of up to 8/256 cells
  4174. + *
  4175. + * @list: device list node
  4176. + * @name: device identifier
  4177. + * @index: unique numeric cluster identifier
  4178. + * @mode: device mode (FP/PP/monitor)
  4179. + * @pari: primary access rights identifier
  4180. + * @si: system information
  4181. + * @bmc: Broadcast Message Control
  4182. + * @cmc: Connectionless Message Control
  4183. + * @mbcs: Multi-Bearer Controllers
  4184. + * @cells: DECT cells
  4185. + */
  4186. +struct dect_cluster {
  4187. + struct list_head list;
  4188. + char name[DECTNAMSIZ];
  4189. + int index;
  4190. +
  4191. + u32 tipc_id;
  4192. + u32 tipc_portref;
  4193. + struct dect_cluster_handle handle;
  4194. +
  4195. + enum dect_cluster_modes mode;
  4196. +
  4197. + spinlock_t lock;
  4198. +
  4199. + struct dect_ari pari;
  4200. + struct dect_si si;
  4201. + u8 rpn;
  4202. +
  4203. + u32 pmid;
  4204. +
  4205. + struct list_head cells;
  4206. + struct dect_bmc bmc;
  4207. + struct dect_cmc cmc;
  4208. + struct list_head mbcs;
  4209. +
  4210. + u32 mcei_rover;
  4211. + struct list_head mac_connections;
  4212. +
  4213. + struct dect_timer_base timer_base[DECT_TIMER_BASE_MAX + 1];
  4214. +};
  4215. +
  4216. +extern struct list_head dect_cluster_list;
  4217. +extern struct dect_cluster *dect_cluster_get_by_index(int index);
  4218. +
  4219. +struct dect_netlink_handler {
  4220. + int (*doit)(const struct sk_buff *, const struct nlmsghdr *,
  4221. + const struct nlattr *[]);
  4222. + int (*dump)(struct sk_buff *, struct netlink_callback *);
  4223. + int (*done)(struct netlink_callback *);
  4224. + const struct nla_policy *policy;
  4225. + unsigned int maxtype;
  4226. +};
  4227. +
  4228. +extern void dect_netlink_register_handlers(const struct dect_netlink_handler *handler,
  4229. + unsigned int base, unsigned int n);
  4230. +extern void dect_netlink_unregister_handlers(unsigned int base, unsigned int n);
  4231. +
  4232. +extern struct sock *dect_nlsk;
  4233. +
  4234. +/**
  4235. + * struct dect_llme_req - LLME netlink request
  4236. + *
  4237. + * @nlh: netlink header
  4238. + * @nlportid: netlink socket port id
  4239. + */
  4240. +struct dect_llme_req {
  4241. + struct nlmsghdr nlh;
  4242. + u32 nlportid;
  4243. +};
  4244. +
  4245. +#include <net/sock.h>
  4246. +
  4247. +extern const struct proto_ops dect_stream_ops;
  4248. +extern const struct proto_ops dect_dgram_ops;
  4249. +
  4250. +struct dect_proto {
  4251. + unsigned int type;
  4252. + unsigned int protocol;
  4253. + int capability;
  4254. + const struct proto_ops *ops;
  4255. + int (*getname)(struct sock *sk,
  4256. + struct sockaddr *uaddr, int *len,
  4257. + int peer);
  4258. + struct proto proto;
  4259. +};
  4260. +
  4261. +#include <net/tcp_states.h>
  4262. +
  4263. +enum {
  4264. + DECT_SK_ESTABLISHED = TCP_ESTABLISHED,
  4265. + DECT_SK_ESTABLISH_PENDING = TCP_SYN_SENT,
  4266. + DECT_SK_RELEASED = TCP_CLOSE,
  4267. + DECT_SK_RELEASE_PENDING = TCP_CLOSING,
  4268. + DECT_SK_LISTEN = TCP_LISTEN,
  4269. +};
  4270. +
  4271. +struct dect_csk {
  4272. + struct sock sk;
  4273. + struct hlist_head accept_queue;
  4274. +};
  4275. +
  4276. +static inline struct dect_csk *dect_csk(const struct sock *sk)
  4277. +{
  4278. + return (struct dect_csk *)sk;
  4279. +}
  4280. +
  4281. +extern int dect_proto_register(struct dect_proto *proto);
  4282. +extern void dect_proto_unregister(struct dect_proto *proto);
  4283. +
  4284. +struct dect_skb_sk_cb {
  4285. + //struct dect_skb_trx_cb cb;
  4286. + int index;
  4287. +};
  4288. +
  4289. +#define DECT_SK_CB(skb) ((struct dect_skb_sk_cb *)(skb)->cb)
  4290. +
  4291. +static inline int dect_sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
  4292. +{
  4293. + /*
  4294. + * Release the transceiver reference, it is only valid in IRQ and
  4295. + * softirq context.
  4296. + */
  4297. + //FIXME
  4298. + //DECT_SK_CB(skb)->index = DECT_CB(skb)->trx->dev->index;
  4299. + return sock_queue_rcv_skb(sk, skb);
  4300. +}
  4301. +
  4302. +struct dect_notification {
  4303. + u32 type;
  4304. +};
  4305. +
  4306. +#define DECT_NOTIFY_CB(skb) ((struct dect_notification *)(skb)->cb)
  4307. +
  4308. +extern struct sk_buff *dect_alloc_notification(u32 type, const void *data,
  4309. + unsigned int size);
  4310. +
  4311. +extern void (*dect_raw_rcv_hook)(struct sk_buff *skb);
  4312. +static inline void dect_raw_rcv(struct sk_buff *skb)
  4313. +{
  4314. + typeof(dect_raw_rcv_hook) dect_raw_rcv;
  4315. +
  4316. + rcu_read_lock();
  4317. + dect_raw_rcv = dect_raw_rcv_hook;
  4318. + if (dect_raw_rcv != NULL)
  4319. + dect_raw_rcv(skb);
  4320. + rcu_read_unlock();
  4321. +}
  4322. +
  4323. +extern int dect_af_module_init(void);
  4324. +extern void dect_af_module_exit(void);
  4325. +
  4326. +extern int dect_bsap_module_init(void);
  4327. +extern void dect_bsap_module_exit(void);
  4328. +extern int dect_ssap_module_init(void);
  4329. +extern void dect_ssap_module_exit(void);
  4330. +
  4331. +extern int dect_netlink_module_init(void);
  4332. +extern void dect_netlink_module_exit(void);
  4333. +
  4334. +extern struct sk_buff *skb_append_frag(struct sk_buff *head, struct sk_buff *skb);
  4335. +extern unsigned int skb_queue_pull(struct sk_buff_head *list, unsigned int len);
  4336. +
  4337. +#endif /* _NET_DECT_DECT_H */
  4338. diff --git a/include/net/dect/dlc.h b/include/net/dect/dlc.h
  4339. new file mode 100644
  4340. index 0000000..84d442c
  4341. --- /dev/null
  4342. +++ b/include/net/dect/dlc.h
  4343. @@ -0,0 +1,463 @@
  4344. +/*
  4345. + * DECT DLC Layer
  4346. + *
  4347. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  4348. + */
  4349. +
  4350. +#ifndef _NET_DECT_DLC_H
  4351. +#define _NET_DECT_DLC_H
  4352. +
  4353. +#include <linux/timer.h>
  4354. +
  4355. +/*
  4356. + * C-Plane data link service
  4357. + */
  4358. +
  4359. +/*
  4360. + * FA-Frame
  4361. + */
  4362. +
  4363. +#define DECT_FA_HDR_SIZE 3
  4364. +
  4365. +struct dect_fa_hdr {
  4366. + u8 addr;
  4367. + u8 ctrl;
  4368. + u8 li;
  4369. +};
  4370. +
  4371. +/*
  4372. + * Address field
  4373. + */
  4374. +
  4375. +#define DECT_FA_ADDR_OFF 0
  4376. +
  4377. +/* New link flag */
  4378. +#define DECT_FA_ADDR_NLF_FLAG 0x80
  4379. +
  4380. +/* Logical Link Number */
  4381. +#define DECT_FA_ADDR_LLN_MASK 0x70
  4382. +#define DECT_FA_ADDR_LLN_SHIFT 4
  4383. +
  4384. +/* Service Access Point Identifier */
  4385. +#define DECT_FA_ADDR_SAPI_MASK 0x0c
  4386. +#define DECT_FA_ADDR_SAPI_SHIFT 2
  4387. +
  4388. +/* Command/Response flag */
  4389. +#define DECT_FA_ADDR_CR_FLAG 0x02
  4390. +
  4391. +/* Reserved bit */
  4392. +#define DECT_FA_ADDR_RES_BIT 0x01
  4393. +
  4394. +/*
  4395. + * Control field
  4396. + */
  4397. +
  4398. +#define DECT_FA_CTRL_OFF 1
  4399. +
  4400. +/*
  4401. + * I-Format: numbered information
  4402. + */
  4403. +
  4404. +#define DECT_FA_CTRL_I_FMT_MASK 0x01
  4405. +#define DECT_FA_CTRL_I_FMT_ID 0x00
  4406. +
  4407. +/* Receive sequence number */
  4408. +#define DECT_FA_CTRL_I_NR_MASK 0xe0
  4409. +#define DECT_FA_CTRL_I_NR_SHIFT 5
  4410. +
  4411. +/* Poll bit */
  4412. +#define DECT_FA_CTRL_I_P_FLAG 0x10
  4413. +
  4414. +/* Send sequence number */
  4415. +#define DECT_FA_CTRL_I_NS_MASK 0x0e
  4416. +#define DECT_FA_CTRL_I_NS_SHIFT 1
  4417. +
  4418. +/* Command */
  4419. +#define DECT_FA_CTRL_I_CMD_I (0x0)
  4420. +
  4421. +/*
  4422. + * S-Format: supervisory functions
  4423. + */
  4424. +
  4425. +#define DECT_FA_CTRL_S_FMT_MASK 0x03
  4426. +#define DECT_FA_CTRL_S_FMT_ID 0x01
  4427. +
  4428. +/* Receive sequence number */
  4429. +#define DECT_FA_CTRL_S_NR_MASK 0xe0
  4430. +#define DECT_FA_CTRL_S_NR_SHIFT 5
  4431. +
  4432. +/* Poll/final bit */
  4433. +#define DECT_FA_CTRL_S_PF_FLAG 0x10
  4434. +
  4435. +/* Command/Response */
  4436. +#define DECT_FA_CTRL_S_CR_MASK 0x0c
  4437. +
  4438. +#define DECT_FA_CTRL_S_CR_RR 0x00
  4439. +#define DECT_FA_CTRL_S_CR_RNR 0x40
  4440. +#define DECT_FA_CTRL_S_CR_REJ 0x80
  4441. +
  4442. +/*
  4443. + * U-Format: unnumbered information
  4444. + */
  4445. +
  4446. +#define DECT_FA_CTRL_U_FMT_MASK 0x03
  4447. +#define DECT_FA_CTRL_U_FMT_ID 0x03
  4448. +
  4449. +/* Unnumbered function bits */
  4450. +#define DECT_FA_CTRL_U_U1_MASK 0xec
  4451. +
  4452. +/* Poll/final bit */
  4453. +#define DECT_FA_CTRL_U_PF_FLAG 0x10
  4454. +
  4455. +/* Command/Response */
  4456. +#define DECT_FA_CTRL_U_CR_MASK 0xef
  4457. +
  4458. +#define DECT_FA_CTRL_U_CR_SABM 0x2c
  4459. +#define DECT_FA_CTRL_U_CR_DM 0x0c
  4460. +#define DECT_FA_CTRL_U_CR_UI 0x00
  4461. +#define DECT_FA_CTRL_U_CR_DISC 0x40
  4462. +#define DECT_FA_CTRL_U_CR_UA 0x60
  4463. +
  4464. +/*
  4465. + * Length Indicator
  4466. + */
  4467. +
  4468. +#define DECT_FA_LI_OFF 2
  4469. +
  4470. +/* Length (octets) */
  4471. +#define DECT_FA_LI_LENGTH_MASK 0xfc
  4472. +#define DECT_FA_LI_LENGTH_SHIFT 2
  4473. +
  4474. +/* More data flag */
  4475. +#define DECT_FA_LI_M_FLAG 0x02
  4476. +
  4477. +/* Extended length indicator bit */
  4478. +#define DECT_FA_LI_EXT_FLAG 0x01
  4479. +
  4480. +/* maximum length value */
  4481. +#define DECT_FA_LI_MAX 63
  4482. +
  4483. +/*
  4484. + * Extended Length indicator
  4485. + */
  4486. +
  4487. +#define DECT_FA_ELI_OFF 3
  4488. +
  4489. +/* Length (octets) */
  4490. +#define DECT_FA_ELI_LENGTH_MASK 0xfc
  4491. +#define DECT_FA_ELI_LENGTH_SHIFT 2
  4492. +
  4493. +struct dect_fa_len {
  4494. + u8 len;
  4495. + bool more;
  4496. +};
  4497. +
  4498. +/*
  4499. + * Fill Field
  4500. + */
  4501. +
  4502. +#define DECT_FA_FILL_PATTERN 0xf0
  4503. +
  4504. +/*
  4505. + * Checksum field
  4506. + */
  4507. +
  4508. +#define DECT_FA_CSUM_SIZE 2
  4509. +
  4510. +/*
  4511. + * Information field
  4512. + */
  4513. +
  4514. +#define DECT_FA_I_MAX (DECT_FA_LI_MAX - DECT_FA_HDR_SIZE - DECT_FA_CSUM_SIZE)
  4515. +
  4516. +
  4517. +/**
  4518. + * struct dect_dli - DECT Data Link Identifier (DLI)
  4519. + *
  4520. + * @lln: Logical Link Number
  4521. + * @mci: Mac Connection Identifier
  4522. + */
  4523. +struct dect_dli {
  4524. + enum dect_llns lln;
  4525. + struct dect_mci mci;
  4526. +};
  4527. +
  4528. +/**
  4529. + * @DECT_LAPC_ULI: unassigned link identifier state (class U/A)
  4530. + * @DECT_LAPC_ALI: assigned link identifier state (class B established)
  4531. + * @DECT_LAPC_ASM: assigned Link Identifier/multiple frame state (class B suspended)
  4532. + */
  4533. +enum dect_lapc_states {
  4534. + DECT_LAPC_ULI,
  4535. + DECT_LAPC_ALI,
  4536. + DECT_LAPC_ASM,
  4537. +};
  4538. +
  4539. +/**
  4540. + * struct dect_lapc - DECT LAPC entity
  4541. + *
  4542. + * @lc: Associated Lc entity
  4543. + * @dli: Data Link Identifier
  4544. + * @sapi: Service Access Point Identifier
  4545. + * @cmd: CR bit setting for commands (PT: 1, FT: 0)
  4546. + * @nlf: New link flag
  4547. + * @v_s: Send state Variable V(S): sequence number of next I-frame
  4548. + * @v_a: Acknowledge state Variable V(A): last I-frame that has been acknowledged
  4549. + * @v_r: Receive state Variable V(R): next expected sequence number
  4550. + * busy: LAPC is in receiver busy condition
  4551. + * @peer_busy: Peer is in receiver busy condition
  4552. + * @window: maximum number of oustanding unacknowledged I-frames
  4553. + * @mod: modulus for sequence number calculations
  4554. + * @retransmit_cnt: Retransmission counter
  4555. + * @retransmit_queue: Retransmission queue
  4556. + * @timer: Retransmission timer (DL.04)
  4557. + */
  4558. +struct dect_lapc {
  4559. + struct sock *sk;
  4560. + struct dect_lc *lc;
  4561. + struct dect_dli dli;
  4562. + enum dect_sapis sapi;
  4563. +
  4564. + bool cmd;
  4565. +
  4566. + enum dect_lapc_states state;
  4567. + bool nlf;
  4568. + u8 v_s;
  4569. + u8 v_a;
  4570. + u8 v_r;
  4571. +
  4572. + bool busy;
  4573. + bool peer_busy;
  4574. +
  4575. + u8 window;
  4576. + u8 mod;
  4577. +
  4578. + u8 retransmit_cnt;
  4579. + struct sk_buff_head retransmit_queue;
  4580. + struct timer_list timer;
  4581. +
  4582. + struct sk_buff *rcv_head;
  4583. +};
  4584. +
  4585. +/* class A window size and sequence number modulus */
  4586. +#define DECT_LAPC_CLASS_A_WINDOW 1
  4587. +#define DECT_LAPC_CLASS_A_MOD 2
  4588. +
  4589. +/* class B window size and sequence number modulus */
  4590. +#define DECT_LAPC_CLASS_B_INITIAL_WINDOW 1
  4591. +#define DECT_LAPC_CLASS_B_WINDOW 3
  4592. +#define DECT_LAPC_CLASS_B_MOD 8
  4593. +
  4594. +/* maximum number of retransmissions */
  4595. +#define DECT_LAPC_RETRANSMIT_MAX 3
  4596. +
  4597. +/* various timer parameters specified in Annex A */
  4598. +#define DECT_LAPC_CLASS_A_ESTABLISH_TIMEOUT (2 * HZ)
  4599. +#define DECT_LAPC_CLASS_B_ESTABLISH_TIMEOUT (2 * HZ)
  4600. +#define DECT_LAPC_RETRANSMISSION_TIMEOUT (1 * HZ)
  4601. +#define DECT_LAPC_LINK_RELEASE_TIMEOUT (2 * HZ)
  4602. +#define DECT_LAPC_LINK_SUSPEND_TIMEOUT (2 * HZ)
  4603. +#define DECT_LAPC_LINK_RESUME_TIMEOUT (2 * HZ)
  4604. +#define DECT_LAPC_CONNECTION_HANDOVER_TIMEOUT (10 * HZ)
  4605. +#define DECT_LAPC_CONNECTION_HANDOVER_INTERVAL (4 * HZ)
  4606. +
  4607. +extern struct dect_lapc *dect_lapc_init(struct sock *sk, const struct dect_dli *dli,
  4608. + enum dect_sapis sapi, struct dect_lc *lc,
  4609. + gfp_t gfp);
  4610. +extern void dect_lapc_destroy(struct dect_lapc *lapc);
  4611. +
  4612. +extern int dect_lapc_establish(struct dect_lapc *lapc);
  4613. +extern void dect_lapc_release(struct dect_lapc *lapc, bool normal);
  4614. +extern int dect_lapc_transmit(struct dect_lapc *lapc);
  4615. +
  4616. +extern struct dect_lapc *dect_ssap_rcv_request(struct dect_lc *lc,
  4617. + const struct dect_dli *dli,
  4618. + enum dect_sapis sapi);
  4619. +
  4620. +/**
  4621. + * struct dect_lc - DECT Lc entity
  4622. + *
  4623. + * @mc: MAC connection
  4624. + * @lsig: link signature for checksumming (lower 16 bits of PMID or 0)
  4625. + * @rx_head: reassembly queue head
  4626. + * @rx_len: target length of current reassembly buffer
  4627. + * @txq: transmit queue
  4628. + * @tx_head: current TX LAPC frame
  4629. + * @tx_len: TX target fragment length
  4630. + * @use: usage count
  4631. + * @lapcs: LAPC entities associated with the Lc
  4632. + * @e_lapc: LAPC performing establishment procedures
  4633. + *
  4634. + * The Lc entity is responsible for framing, logical channel selection and
  4635. + * fragmenting of LAPC PDUs. There is one Lc entity per MAC connection.
  4636. + */
  4637. +struct dect_lc {
  4638. + struct dect_mac_conn *mc;
  4639. + u16 lsig;
  4640. +
  4641. + struct sk_buff *rx_head;
  4642. + u8 rx_len;
  4643. +
  4644. + struct sk_buff_head txq;
  4645. + struct sk_buff *tx_head;
  4646. + u8 tx_len;
  4647. +
  4648. + u8 use;
  4649. + struct dect_lapc *lapcs[DECT_LLN_UNASSIGNED + 1];
  4650. + struct dect_lapc *elapc;
  4651. +};
  4652. +
  4653. +#define DECT_LC_LSIG_MASK 0xffff
  4654. +
  4655. +extern struct dect_lc *dect_lc_init(struct dect_mac_conn *mc, gfp_t gfp);
  4656. +extern void dect_lc_destroy(struct dect_lc *lc);
  4657. +
  4658. +extern void dect_lc_bind(struct dect_lc *lc, struct dect_lapc *lapc);
  4659. +extern void dect_lc_unbind(struct dect_lc *lc, struct dect_lapc *lapc);
  4660. +
  4661. +/**
  4662. + * struct dect_lb - DECT Lb entity (C-plane broadcast service)
  4663. + *
  4664. + *
  4665. + */
  4666. +struct dect_lb {
  4667. +};
  4668. +
  4669. +#define DECT_LB_SHORT_FRAME_SIZE 3
  4670. +#define DECT_LB_LONG_FRAME_SIZE 5
  4671. +#define DECT_LB_EXTENDED_FRAME_SIZE_MAX (6 * DECT_LB_LONG_FRAME_SIZE)
  4672. +
  4673. +#include <net/sock.h>
  4674. +
  4675. +/**
  4676. + * struct dect_dlc_fbx_ops - DLC U-plane lower (FBx) entity ops
  4677. + *
  4678. + */
  4679. +struct dect_fbx;
  4680. +struct dect_fbx_ops {
  4681. + struct sk_buff *(*dequeue)(struct dect_fbx *fbx);
  4682. + void (*enqueue)(struct dect_fbx *fbx,
  4683. + struct sk_buff *skb);
  4684. +};
  4685. +
  4686. +struct dect_fbx {
  4687. + const struct dect_fbx_ops *ops;
  4688. +};
  4689. +
  4690. +extern const struct dect_fbx_ops dect_fbn_ops;
  4691. +
  4692. +struct dect_lux;
  4693. +struct dect_lux_ops {
  4694. + struct sk_buff *(*dequeue)(struct dect_lux *lux);
  4695. + void (*enqueue)(struct dect_lux *lux,
  4696. + struct sk_buff *skb);
  4697. + void (*disconnect)(struct dect_lux *lux);
  4698. +};
  4699. +
  4700. +/**
  4701. + * struct dect_lux - DLC U-plane upper (LUx) entity
  4702. + *
  4703. + * @fpx: FBx entity
  4704. + */
  4705. +struct dect_lux {
  4706. + const struct dect_lux_ops *ops;
  4707. + struct dect_fbx fbx;
  4708. +};
  4709. +
  4710. +/**
  4711. + * dect_mac_connection_states - DECT MAC connection states as viewed by the DLC
  4712. + *
  4713. + * @DECT_MAC_CONN_CLOSED:
  4714. + * @DECT_MAC_CONN_OPEN_PENDING:
  4715. + * @DECT_MAC_CONN_OPEN:
  4716. + */
  4717. +enum dect_mac_conn_states {
  4718. + DECT_MAC_CONN_CLOSED,
  4719. + DECT_MAC_CONN_OPEN_PENDING,
  4720. + DECT_MAC_CONN_OPEN,
  4721. +};
  4722. +
  4723. +/**
  4724. + * struct dect_mac_conn - DECT MAC connection as viewed by the DLC
  4725. + *
  4726. + * @list: Cluster connection list node
  4727. + * @cl: Cluster
  4728. + * @mcei: MAC Connection Endpoint Identification
  4729. + * @mci: MAC Connection Identifier (BMCI or AMCI)
  4730. + * @state: Connection state
  4731. + * @service: Service offered by the connection
  4732. + * @ck: cipher key
  4733. + */
  4734. +struct dect_mac_conn {
  4735. + struct list_head list;
  4736. + struct dect_cluster *cl;
  4737. +
  4738. + u32 mcei;
  4739. + struct dect_mci mci;
  4740. + struct dect_mac_conn_params mcp;
  4741. + enum dect_mac_conn_states state;
  4742. + u64 ck;
  4743. +
  4744. + u8 use;
  4745. + struct dect_lc *lc;
  4746. + struct dect_fbx *fbx;
  4747. +};
  4748. +
  4749. +extern struct dect_mac_conn *dect_mac_conn_init(struct dect_cluster *cl,
  4750. + const struct dect_mci *mci,
  4751. + const struct dect_mbc_id *id);
  4752. +extern void dect_dlc_mac_conn_destroy(struct dect_mac_conn *mc);
  4753. +extern struct dect_mac_conn *dect_mac_conn_get_by_mci(const struct dect_cluster *cl,
  4754. + const struct dect_mci *mci);
  4755. +
  4756. +extern void dect_dlc_mac_conn_bind(struct dect_mac_conn *mc);
  4757. +extern void dect_dlc_mac_conn_unbind(struct dect_mac_conn *mc);
  4758. +extern int dect_dlc_mac_conn_establish(struct dect_mac_conn *mc,
  4759. + const struct dect_mac_conn_params *mcp);
  4760. +
  4761. +extern int dect_mac_con_cfm(struct dect_cluster *cl, u32 mcei,
  4762. + const struct dect_mac_conn_params *mcp);
  4763. +extern int dect_mac_con_ind(struct dect_cluster *cl,
  4764. + const struct dect_mbc_id *id,
  4765. + const struct dect_mac_conn_params *mcp);
  4766. +
  4767. +extern int dect_dlc_mac_conn_enc_key_req(struct dect_mac_conn *mc, u64 key);
  4768. +extern int dect_dlc_mac_conn_enc_eks_req(struct dect_mac_conn *mc,
  4769. + enum dect_cipher_states status);
  4770. +extern void dect_mac_enc_eks_cfm(struct dect_cluster *cl, u32 mcei,
  4771. + enum dect_cipher_states status);
  4772. +extern void dect_mac_enc_eks_ind(struct dect_cluster *cl, u32 mcei,
  4773. + enum dect_cipher_states status);
  4774. +
  4775. +extern void dect_dlc_mac_dis_req(struct dect_mac_conn *mc);
  4776. +extern int dect_mac_dis_ind(struct dect_cluster *cl, u32 mcei,
  4777. + enum dect_release_reasons reason);
  4778. +
  4779. +extern void dect_cplane_notify_state_change(struct dect_mac_conn *mc);
  4780. +extern void dect_cplane_mac_dis_ind(const struct dect_mac_conn *mc,
  4781. + enum dect_release_reasons reason);
  4782. +extern void dect_cplane_mac_enc_eks_ind(const struct dect_mac_conn *mc,
  4783. + enum dect_cipher_states status);
  4784. +
  4785. +extern void dect_cplane_rcv(struct dect_mac_conn *mc,
  4786. + enum dect_data_channels chan,
  4787. + struct sk_buff *skb);
  4788. +extern struct sk_buff *dect_cplane_dtr(struct dect_mac_conn *mc,
  4789. + enum dect_data_channels chan);
  4790. +
  4791. +extern void dect_uplane_rcv(struct dect_mac_conn *mc,
  4792. + enum dect_data_channels chan,
  4793. + struct sk_buff *skb);
  4794. +extern struct sk_buff *dect_uplane_dtr(struct dect_mac_conn *mc,
  4795. + enum dect_data_channels chan);
  4796. +
  4797. +extern void dect_mac_co_data_ind(struct dect_cluster *cl, u32 mcei,
  4798. + enum dect_data_channels chan,
  4799. + struct sk_buff *skb);
  4800. +extern struct sk_buff *dect_mac_co_dtr_ind(struct dect_cluster *cl, u32 mcei,
  4801. + enum dect_data_channels chan);
  4802. +
  4803. +extern void dect_bsap_rcv(const struct dect_cluster *cl, struct sk_buff *skb);
  4804. +extern void dect_mac_page_ind(struct dect_cluster *cl, struct sk_buff *skb);
  4805. +
  4806. +#endif /* _NET_DECT_DLC_H */
  4807. diff --git a/include/net/dect/dsc.h b/include/net/dect/dsc.h
  4808. new file mode 100644
  4809. index 0000000..423a646
  4810. --- /dev/null
  4811. +++ b/include/net/dect/dsc.h
  4812. @@ -0,0 +1,12 @@
  4813. +#ifndef _NET_DECT_DSC_H
  4814. +#define _NET_DECT_DSC_H
  4815. +
  4816. +static inline __le64 dect_dsc_iv(u32 mfn, u8 framenum)
  4817. +{
  4818. + return cpu_to_le64((mfn << 4) + framenum);
  4819. +}
  4820. +
  4821. +extern void dect_dsc_keystream(uint64_t iv, const uint8_t *key,
  4822. + uint8_t *output, unsigned int len);
  4823. +
  4824. +#endif /* _NET_DECT_DSC_H */
  4825. diff --git a/include/net/dect/identities.h b/include/net/dect/identities.h
  4826. new file mode 100644
  4827. index 0000000..a924d35
  4828. --- /dev/null
  4829. +++ b/include/net/dect/identities.h
  4830. @@ -0,0 +1,194 @@
  4831. +#ifndef _NET_DECT_IDENTITIES_H
  4832. +#define _NET_DECT_IDENTITIES_H
  4833. +
  4834. +/*
  4835. + * Acess Rights Identity (ARI)
  4836. + */
  4837. +
  4838. +#define DECT_ARI_ARC_MASK 0xe000000000000000ULL
  4839. +#define DECT_ARI_ARC_SHIFT 61
  4840. +
  4841. +/* Class A */
  4842. +#define DECT_ARI_A_EMC_MASK 0x1fffe00000000000ULL
  4843. +#define DECT_ARI_A_EMC_SHIFT 45
  4844. +
  4845. +#define DECT_ARI_A_FPN_MASK 0x00001ffff0000000ULL
  4846. +#define DECT_ARI_A_FPN_SHIFT 28
  4847. +
  4848. +/* Class B */
  4849. +#define DECT_ARI_B_EIC_MASK 0x1fffe00000000000ULL
  4850. +#define DECT_ARI_B_EIC_SHIFT 45
  4851. +
  4852. +#define DECT_ARI_B_FPN_MASK 0x00001fe000000000ULL
  4853. +#define DECT_ARI_B_FPN_SHIFT 37
  4854. +
  4855. +#define DECT_ARI_B_FPS_MASK 0x0000001e00000000ULL
  4856. +#define DECT_ARI_B_FPS_SHIFT 33
  4857. +
  4858. +/* Class C */
  4859. +#define DECT_ARI_C_POC_MASK 0x1fffe00000000000ULL
  4860. +#define DECT_ARI_C_POC_SHIFT 45
  4861. +
  4862. +#define DECT_ARI_C_FPN_MASK 0x00001fe000000000ULL
  4863. +#define DECT_ARI_C_FPN_SHIFT 37
  4864. +
  4865. +#define DECT_ARI_C_FPS_MASK 0x0000001e00000000ULL
  4866. +#define DECT_ARI_C_FPS_SHIFT 33
  4867. +
  4868. +/* Class D */
  4869. +#define DECT_ARI_D_GOP_MASK 0x1ffffe0000000000ULL
  4870. +#define DECT_ARI_D_GOP_SHIFT 41
  4871. +
  4872. +#define DECT_ARI_D_FPN_MASK 0x000001fe00000000ULL
  4873. +#define DECT_ARI_D_FPN_SHIFT 33
  4874. +
  4875. +/* Class E */
  4876. +#define DECT_ARI_E_FIL_MASK 0x1fffe00000000000ULL
  4877. +#define DECT_ARI_E_FIL_SHIFT 45
  4878. +
  4879. +#define DECT_ARI_E_FPN_MASK 0x00001ffe00000000ULL
  4880. +#define DECT_ARI_E_FPN_SHIFT 33
  4881. +
  4882. +#include <linux/dect_netlink.h>
  4883. +
  4884. +struct dect_ari {
  4885. + enum dect_ari_classes arc;
  4886. + u32 fpn;
  4887. + u32 fps;
  4888. + union {
  4889. + u16 emc;
  4890. + u16 eic;
  4891. + u16 poc;
  4892. + u32 gop;
  4893. + u16 fil;
  4894. + };
  4895. +};
  4896. +
  4897. +enum dect_ari_lengths {
  4898. + DECT_ARC_A_LEN = 36,
  4899. + DECT_ARC_B_LEN = 31,
  4900. + DECT_ARC_C_LEN = 31,
  4901. + DECT_ARC_D_LEN = 31,
  4902. + DECT_ARC_E_LEN = 31,
  4903. +};
  4904. +
  4905. +extern bool dect_ari_masked_cmp(const struct dect_ari *a1,
  4906. + const struct dect_ari *a2,
  4907. + const struct dect_ari *m);
  4908. +extern bool dect_ari_cmp(const struct dect_ari *a1, const struct dect_ari *a2);
  4909. +extern u8 dect_parse_ari(struct dect_ari *ari, u64 a);
  4910. +extern u64 dect_build_ari(const struct dect_ari *ari);
  4911. +
  4912. +/*
  4913. + * RFPI
  4914. + */
  4915. +
  4916. +#define DECT_RFPI_E_FLAG 0x0080000000000000ULL
  4917. +#define DECT_RFPI_ARI_SHIFT 9
  4918. +#define DECT_RFPI_RPN_SHIFT 16
  4919. +
  4920. +struct dect_idi;
  4921. +extern bool dect_rfpi_cmp(const struct dect_idi *i1, const struct dect_idi *i2);
  4922. +extern u64 dect_build_rfpi(const struct dect_idi *idi);
  4923. +
  4924. +/*
  4925. + * FMID (Fixed MAC Identifier)
  4926. + */
  4927. +
  4928. +#define DECT_FMID_MASK 0x0fff
  4929. +#define DECT_FMID_SIZE 12
  4930. +
  4931. +extern u16 dect_build_fmid(const struct dect_idi *idi);
  4932. +
  4933. +/*
  4934. + * PMID (Portable MAC Identifier)
  4935. + */
  4936. +
  4937. +#define DECT_PMID_MASK 0x000fffff
  4938. +#define DECT_PMID_SIZE 20
  4939. +
  4940. +#define DECT_PMID_DEFAULT_ID_MASK 0x000f0000
  4941. +#define DECT_PMID_DEFAULT_ID 0x000e0000
  4942. +#define DECT_PMID_DEFAULT_NUM_MASK 0x0000ffff
  4943. +
  4944. +#define DECT_PMID_EMERGENCY_ID_MASK 0x000ff000
  4945. +#define DECT_PMID_EMERGENCY_ID 0x000f1000
  4946. +#define DECT_PMID_EMERGENCY_TPUI_MASK 0x00000fff
  4947. +
  4948. +#define DECT_PMID_ASSIGNED_TPUI_MASK 0x000fffff
  4949. +
  4950. +/**
  4951. + * @DECT_PMID_DEFAULT: 1110 + arbitrary number (16 bits)
  4952. + * @DECT_PMID_ASSIGNED: Assigned individual TPUI
  4953. + * @DECT_PMID_EMERGENCY: 1111 0001 + 12 bits of emergency TPUI
  4954. + */
  4955. +enum dect_pmid_types {
  4956. + DECT_PMID_DEFAULT,
  4957. + DECT_PMID_ASSIGNED,
  4958. + DECT_PMID_EMERGENCY,
  4959. +};
  4960. +
  4961. +struct dect_pmid {
  4962. + enum dect_pmid_types type;
  4963. + union {
  4964. + u32 tpui;
  4965. + u32 num;
  4966. + };
  4967. +};
  4968. +
  4969. +extern void dect_parse_pmid(struct dect_pmid *pmid, u32 p);
  4970. +extern u32 dect_build_pmid(const struct dect_pmid *pmid);
  4971. +extern bool dect_pmid_cmp(const struct dect_pmid *p1, const struct dect_pmid *p2);
  4972. +
  4973. +/*
  4974. + * ECN (Exchanged Connection Number)
  4975. + */
  4976. +
  4977. +#define DECT_ECN_MASK 0xf
  4978. +#define DECT_ECN_SIZE 4
  4979. +
  4980. +/*
  4981. + * LCN (Logical Connection Number)
  4982. + */
  4983. +
  4984. +#define DECT_LCN_MASK 0x7
  4985. +#define DECT_LCN_SIZE 3
  4986. +
  4987. +/**
  4988. + * struct dect_mci - MAC connection identifier
  4989. + *
  4990. + * @ari: DECT ARI
  4991. + * @pmid: Portable MAC Identity
  4992. + * @lcn: Logical Connection Number
  4993. + */
  4994. +struct dect_mci {
  4995. + struct dect_ari ari;
  4996. + struct dect_pmid pmid;
  4997. + u8 lcn;
  4998. +};
  4999. +
  5000. +extern int dect_parse_mci(struct dect_mci *mci, u64 m);
  5001. +extern u64 dect_build_mci(const struct dect_mci *mci);
  5002. +
  5003. +/*
  5004. + * Data Link Identifier
  5005. + */
  5006. +
  5007. +/**
  5008. + * struct dect_dlei - DECT Data Link Endpoint Identifier (DLEI)
  5009. + *
  5010. + */
  5011. +struct dect_dlei {
  5012. + struct dect_mci mci;
  5013. + enum dect_sapis sapi;
  5014. + enum dect_llns lln;
  5015. +};
  5016. +
  5017. +/**
  5018. + * struct dect_ulei - DECT U-Plane Link Endpoint Identifier
  5019. + */
  5020. +struct dect_ulei {
  5021. + struct dect_mci mci;
  5022. +};
  5023. +
  5024. +#endif /* _NET_DECT_IDENTITIES_H */
  5025. diff --git a/include/net/dect/mac.h b/include/net/dect/mac.h
  5026. new file mode 100644
  5027. index 0000000..74c0a9e
  5028. --- /dev/null
  5029. +++ b/include/net/dect/mac.h
  5030. @@ -0,0 +1,837 @@
  5031. +/*
  5032. + * DECT MAC Layer - Header and global definitions
  5033. + *
  5034. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  5035. + */
  5036. +
  5037. +#ifndef _NET_DECT_MAC_H
  5038. +#define _NET_DECT_MAC_H
  5039. +
  5040. +#include <net/dect/identities.h>
  5041. +
  5042. +/*
  5043. + * A-Field
  5044. + */
  5045. +
  5046. +#define DECT_A_FIELD_SIZE 8
  5047. +
  5048. +#define DECT_RA_FIELD_SIZE 2
  5049. +#define DECT_RA_FIELD_OFF 6
  5050. +
  5051. +/*
  5052. + * Header field
  5053. + */
  5054. +
  5055. +#define DECT_HDR_FIELD_SIZE 1
  5056. +#define DECT_HDR_FIELD_OFF 0
  5057. +
  5058. +#define DECT_HDR_TA_OFF 0
  5059. +#define DECT_HDR_TA_MASK 0xe0
  5060. +#define DECT_HDR_TA_SHIFT 5
  5061. +
  5062. +#define DECT_HDR_Q1_OFF 0
  5063. +#define DECT_HDR_Q1_FLAG 0x10
  5064. +
  5065. +#define DECT_HDR_BA_OFF 0
  5066. +#define DECT_HDR_BA_MASK 0x0e
  5067. +#define DECT_HDR_BA_SHIFT 1
  5068. +
  5069. +#define DECT_HDR_Q2_OFF 0
  5070. +#define DECT_HDR_Q2_FLAG 0x01
  5071. +
  5072. +/*
  5073. + * T-Field
  5074. + */
  5075. +
  5076. +#define DECT_T_FIELD_OFF 1
  5077. +#define DECT_T_FIELD_SIZE 5
  5078. +
  5079. +/**
  5080. + * dect_tail_identification - MAC layer T-Field identification
  5081. + *
  5082. + * @DECT_TI_CT_PKT_0: C_T data packet number 0
  5083. + * @DECT_TI_CT_PKT_1: C_T data packet number 1
  5084. + * @DECT_TI_NT_CL: Identities information on connectionless bearer
  5085. + * @DECT_TI_NT: Identities information
  5086. + * @DECT_TI_QT: Multiframe synchronisation und system information
  5087. + * @DECT_TI_RESERVED: Reserved
  5088. + * @DECT_TI_MT: MAC layer control
  5089. + * @DECT_TI_PT: Paging tail (RFP only)
  5090. + * @DECT_TI_MT_PKT_0: MAC layer control (first PP transmission, PP only)
  5091. + */
  5092. +enum dect_tail_identifications {
  5093. + DECT_TI_CT_PKT_0 = 0x0 << DECT_HDR_TA_SHIFT,
  5094. + DECT_TI_CT_PKT_1 = 0x1 << DECT_HDR_TA_SHIFT,
  5095. + DECT_TI_NT_CL = 0x2 << DECT_HDR_TA_SHIFT,
  5096. + DECT_TI_NT = 0x3 << DECT_HDR_TA_SHIFT,
  5097. + DECT_TI_QT = 0x4 << DECT_HDR_TA_SHIFT,
  5098. + DECT_TI_RESERVED = 0x5 << DECT_HDR_TA_SHIFT,
  5099. + DECT_TI_MT = 0x6 << DECT_HDR_TA_SHIFT,
  5100. + DECT_TI_PT = 0x7 << DECT_HDR_TA_SHIFT,
  5101. + DECT_TI_MT_PKT_0 = 0x7 << DECT_HDR_TA_SHIFT,
  5102. +};
  5103. +
  5104. +struct dect_skb_a_cb {
  5105. + enum dect_tail_identifications id;
  5106. +};
  5107. +
  5108. +#define DECT_A_CB(skb) ((struct dect_skb_a_cb *)(skb)->cb)
  5109. +
  5110. +/*
  5111. + * Identities channel (N-channel)
  5112. + */
  5113. +
  5114. +/* Identities information */
  5115. +#define DECT_NT_ID_RFPI_LEN 5
  5116. +
  5117. +/**
  5118. + * @e: indicates whether SARIs are available
  5119. + * @pari: primary access rights identifier
  5120. + * @rpn: radio part number
  5121. + */
  5122. +struct dect_idi {
  5123. + bool e;
  5124. + struct dect_ari pari;
  5125. + u8 rpn;
  5126. +};
  5127. +
  5128. +/*
  5129. + * System information and multiframe marker (Q-channel)
  5130. + */
  5131. +
  5132. +/* RFP Q-channel T-MUX rules: only frame 8 */
  5133. +#define DECT_Q_CHANNEL_FRAME 8
  5134. +
  5135. +/* System information header */
  5136. +#define DECT_QT_H_MASK 0x00f0000000000000ULL
  5137. +#define DECT_QT_H_SHIFT 52
  5138. +
  5139. +/**
  5140. + * dect_system_information_types - codes for system information messages
  5141. + *
  5142. + * @DECT_QT_SI_SSI: static system information
  5143. + * @DECT_QT_SI_ERFC: extended RF carriers
  5144. + * @DECT_QT_SI_FPC: fixed part capabilities
  5145. + * @DECT_QT_SI_EFPC: extended fixed part capabilities
  5146. + * @DECT_QT_SI_SARI: SARI list contents
  5147. + * @DECT_QT_SI_MFN: multi-frame number
  5148. + * @DECT_QT_SI_ESC: escape
  5149. + * @DECT_QT_SI_ERFC2: extended RF carriers part 2
  5150. + * @DECT_QT_SI_TXI transmit information
  5151. + * @DECT_QT_SI_EFPC2: extended fixed part capabilities part 2
  5152. + */
  5153. +enum dect_mac_system_information_types {
  5154. + DECT_QT_SI_SSI = 0x0ULL << DECT_QT_H_SHIFT,
  5155. + DECT_QT_SI_SSI2 = 0x1ULL << DECT_QT_H_SHIFT,
  5156. + DECT_QT_SI_ERFC = 0x2ULL << DECT_QT_H_SHIFT,
  5157. + DECT_QT_SI_FPC = 0x3ULL << DECT_QT_H_SHIFT,
  5158. + DECT_QT_SI_EFPC = 0x4ULL << DECT_QT_H_SHIFT,
  5159. + DECT_QT_SI_SARI = 0x5ULL << DECT_QT_H_SHIFT,
  5160. + DECT_QT_SI_MFN = 0x6ULL << DECT_QT_H_SHIFT,
  5161. + DECT_QT_SI_ESC = 0x7ULL << DECT_QT_H_SHIFT,
  5162. + DECT_QT_SI_ERFC2 = 0x9ULL << DECT_QT_H_SHIFT,
  5163. + DECT_QT_SI_TXI = 0xbULL << DECT_QT_H_SHIFT,
  5164. + DECT_QT_SI_EFPC2 = 0xcULL << DECT_QT_H_SHIFT,
  5165. +};
  5166. +
  5167. +/*
  5168. + * Static system information - repeated every 8 multiframes
  5169. + */
  5170. +
  5171. +#define DECT_QT_SSI_FREQ 8
  5172. +
  5173. +/* normal reverse */
  5174. +#define DECT_QT_SSI_NR_FLAG 0x0010000000000000ULL
  5175. +
  5176. +/* slot number */
  5177. +#define DECT_QT_SSI_SN_MASK 0x000f000000000000ULL
  5178. +#define DECT_QT_SSI_SN_SHIFT 48
  5179. +
  5180. +/* start position */
  5181. +#define DECT_QT_SSI_SP_MASK 0x0000c00000000000ULL
  5182. +#define DECT_QT_SSI_SP_SHIFT 46
  5183. +
  5184. +/* escape bit */
  5185. +#define DECT_QT_SSI_ESC_FLAG 0x0000200000000000ULL
  5186. +
  5187. +/* number of transceivers */
  5188. +#define DECT_QT_SSI_TXS_MASK 0x0000180000000000ULL
  5189. +#define DECT_QT_SSI_TXS_SHIFT 43
  5190. +
  5191. +/* extended RF carrier information available */
  5192. +#define DECT_QT_SSI_MC_FLAG 0x0000040000000000ULL
  5193. +
  5194. +/* RF carriers available */
  5195. +#define DECT_QT_SSI_RFCARS_MASK 0x000003ff00000000ULL
  5196. +#define DECT_QT_SSI_RFCARS_SHIFT 32
  5197. +
  5198. +/* carrier number */
  5199. +#define DECT_QT_SSI_CN_MASK 0x000000003f000000ULL
  5200. +#define DECT_QT_SSI_CN_SHIFT 24
  5201. +
  5202. +/* primary scan carrier number */
  5203. +#define DECT_QT_SSI_PSCN_MASK 0x00000000003f0000ULL
  5204. +#define DECT_QT_SSI_PSCN_SHIFT 16
  5205. +
  5206. +struct dect_ssi {
  5207. + bool nr;
  5208. + bool mc;
  5209. + u16 rfcars;
  5210. + u8 sn;
  5211. + u8 sp;
  5212. + u8 txs;
  5213. + u8 cn;
  5214. + u8 pscn;
  5215. +};
  5216. +
  5217. +/*
  5218. + * Extended RF carrier information
  5219. + */
  5220. +
  5221. +#define DECT_QT_ERFC_FREQ 8
  5222. +
  5223. +#define DECT_QT_ERFC_RFCARS_MASK 0x000fffffe0000000ULL
  5224. +#define DECT_QT_ERFC_RFCARS_SHIFT 1
  5225. +
  5226. +#define DECT_QT_ERFC_RFBAND_MASK 0x000000001f000000ULL
  5227. +#define DECT_QT_ERFC_RFBAND_SHIFT 24
  5228. +
  5229. +#define DECT_QT_ERFC_ERFC2_FLAG 0x0000000000800000ULL
  5230. +
  5231. +#define DECT_QT_ERFC_NUM_RFCARS_MASK 0x00000000003f0000ULL
  5232. +#define DECT_QT_ERFC_NUM_RFCARS_SHIFT 16
  5233. +
  5234. +struct dect_erfc {
  5235. + u32 rfcars;
  5236. + u8 band;
  5237. + u8 num_rfcars;
  5238. + bool erfc2;
  5239. +};
  5240. +
  5241. +/*
  5242. + * Fixed Part capabilities
  5243. + */
  5244. +
  5245. +#define DECT_QT_FPC_FREQ 8
  5246. +
  5247. +#define DECT_QT_FPC_CAPABILITY_MASK 0x000fffff00000000ULL
  5248. +#define DECT_QT_FPC_CAPABILITY_SHIFT 32
  5249. +
  5250. +#define DECT_QT_FPC_HLC_MASK 0x00000000ffff0000ULL
  5251. +#define DECT_QT_FPC_HLC_SHIFT 16
  5252. +
  5253. +struct dect_fpc {
  5254. + u32 fpc;
  5255. + u16 hlc;
  5256. +};
  5257. +
  5258. +/*
  5259. + * Extended Fixed Part capabilities
  5260. + */
  5261. +
  5262. +#define DECT_QT_EFPC_EFPC_MASK 0x000fff8000000000ULL
  5263. +#define DECT_QT_EFPC_EFPC_SHIFT 39
  5264. +
  5265. +#define DECT_QT_EFPC_EHLC_MASK 0x0000007fffff0000ULL
  5266. +#define DECT_QT_EFPC_EHLC_SHIFT 16
  5267. +
  5268. +struct dect_efpc {
  5269. + u16 fpc;
  5270. + u32 hlc;
  5271. +};
  5272. +
  5273. +#define DECT_QT_EFPC2_FPC_MASK 0x000fff0000000000ULL
  5274. +#define DECT_QT_EFPC2_FPC_SHIFT 40
  5275. +
  5276. +#define DECT_QT_EFPC2_HLC_MASK 0x000000ffffff0000ULL
  5277. +#define DECT_QT_EFPC2_HLC_SHIFT 16
  5278. +
  5279. +struct dect_efpc2 {
  5280. + u16 fpc;
  5281. + u32 hlc;
  5282. +};
  5283. +
  5284. +/*
  5285. + * SARI message
  5286. + */
  5287. +
  5288. +#define DECT_QT_SARI_FREQ 4
  5289. +
  5290. +#define DECT_QT_SARI_LIST_CYCLE_MASK 0x00000e0000000000ULL
  5291. +#define DECT_QT_SARI_LIST_CYCLE_SHIFT 41
  5292. +
  5293. +#define DECT_QT_SARI_TARI_FLAG 0x0000010000000000ULL
  5294. +
  5295. +#define DECT_QT_SARI_BLACK_FLAG 0x0000008000000000ULL
  5296. +
  5297. +#define DECT_QT_SARI_ARI_MASK 0x0000007fffffff00ULL
  5298. +#define DECT_QT_SARI_ARI_SHIFT 25
  5299. +
  5300. +struct dect_sari {
  5301. + u8 list_cycle;
  5302. + bool tari;
  5303. + bool black;
  5304. + struct dect_ari ari;
  5305. +};
  5306. +
  5307. +#define DECT_SARI_CYCLE_MAX 16
  5308. +
  5309. +/*
  5310. + * Multiframe number - repeated every 8 multiframes if supported
  5311. + */
  5312. +
  5313. +#define DECT_QT_MFN_FREQ 8
  5314. +
  5315. +#define DECT_QT_MFN_MASK 0x000000ffffff0000ULL
  5316. +#define DECT_QT_MFN_SHIFT 16
  5317. +
  5318. +struct dect_mfn {
  5319. + u32 num;
  5320. +};
  5321. +
  5322. +/*
  5323. + * Extended RF carrier information part 2
  5324. + */
  5325. +
  5326. +#define DECT_QT_TXI_ERFC2_FREQ 8
  5327. +
  5328. +#define DECT_QT_ERFC2_RFCARS_MASK 0x000fffffffe00000ULL
  5329. +#define DECT_QT_ERFC2_RFCARS_SHIFT 21
  5330. +
  5331. +struct dect_erfc2 {
  5332. + u32 rfcars;
  5333. +};
  5334. +
  5335. +/*
  5336. + * Transmit Information
  5337. + */
  5338. +
  5339. +#define DECT_QT_TXI_FREQ 8
  5340. +
  5341. +#define DECT_QT_TXI_TYPE_MASK 0x000f000000000000ULL
  5342. +#define DECT_QT_TXI_TYPE_SHIFT 48
  5343. +
  5344. +#define DECT_QT_TXI_PWL_MASK 0x0000ff0000000000ULL
  5345. +#define DECT_QT_TXI_PWL_SHIFT 40
  5346. +
  5347. +/*
  5348. + * Extended fixed part capabilitiees part 2
  5349. + */
  5350. +
  5351. +/*
  5352. + * Paging Tail (P-channel)
  5353. + */
  5354. +
  5355. +#define DECT_PT_HDR_EXTEND_FLAG 0x0080000000000000ULL
  5356. +
  5357. +#define DECT_PT_HDR_LENGTH_MASK 0x0070000000000000ULL
  5358. +#define DECT_PT_HDR_LENGTH_SHIFT 52
  5359. +
  5360. +/**
  5361. + * @DECT_PT_ZERO_PAGE: zero length page
  5362. + * @DECT_PT_SHORT_PAGE: short page
  5363. + * @DECT_PT_FULL_PAGE: full page
  5364. + * @DECT_PT_MAX_RESUME_PAGE: MAC resume and control page
  5365. + * @DECT_PT_LONG_PAGE: not the last 36 bits of a long page
  5366. + * @DECT_PT_LONG_PAGE_FIRST: the first 36 bits of a long page
  5367. + * @DECT_PT_LONG_PAGE_LAST: the last 36 bits of a long page
  5368. + * @DECT_PT_LONG_PAGE_ALL: all of a long page (first and last)
  5369. + *
  5370. + */
  5371. +enum dect_page_lengths {
  5372. + DECT_PT_ZERO_PAGE = 0x0ULL << DECT_PT_HDR_LENGTH_SHIFT,
  5373. + DECT_PT_SHORT_PAGE = 0x1ULL << DECT_PT_HDR_LENGTH_SHIFT,
  5374. + DECT_PT_FULL_PAGE = 0x2ULL << DECT_PT_HDR_LENGTH_SHIFT,
  5375. + DECT_PT_RESUME_PAGE = 0x3ULL << DECT_PT_HDR_LENGTH_SHIFT,
  5376. + DECT_PT_LONG_PAGE = 0x4ULL << DECT_PT_HDR_LENGTH_SHIFT,
  5377. + DECT_PT_LONG_PAGE_FIRST = 0x5ULL << DECT_PT_HDR_LENGTH_SHIFT,
  5378. + DECT_PT_LONG_PAGE_LAST = 0x6ULL << DECT_PT_HDR_LENGTH_SHIFT,
  5379. + DECT_PT_LONG_PAGE_ALL = 0x7ULL << DECT_PT_HDR_LENGTH_SHIFT,
  5380. +};
  5381. +
  5382. +/* zero length pages */
  5383. +#define DECT_PT_ZP_RFPI_MASK 0x000fffff00000000ULL
  5384. +#define DECT_PT_ZP_RFPI_SHIFT 32
  5385. +
  5386. +/* short page B_S channel data */
  5387. +#define DECT_PT_SP_BS_DATA_MASK 0x000fffff00000000ULL
  5388. +#define DECT_PT_SP_BS_DATA_SHIFT 32
  5389. +#define DECT_PT_SP_BS_DATA_SIZE 3
  5390. +
  5391. +/* long and full page B_S channel data */
  5392. +#define DECT_PT_LFP_BS_DATA_MASK 0x000fffffffff0000ULL
  5393. +#define DECT_PT_LFP_BS_DATA_SHIFT 16
  5394. +#define DECT_PT_LFP_BS_DATA_SIZE 5
  5395. +
  5396. +struct dect_page {
  5397. + bool extend;
  5398. + enum dect_page_lengths length;
  5399. + u32 rfpi;
  5400. +};
  5401. +
  5402. +/* MAC layer information */
  5403. +#define DECT_PT_INFO_TYPE_MASK 0x00000000f0000000ULL
  5404. +#define DECT_PT_INFO_TYPE_SHIFT 28
  5405. +#define DECT_PT_INFO_TYPE_SIZE 2
  5406. +
  5407. +/**
  5408. + * @DECT_PT_IT_FILL_BITS_OR_BLIND_LONG_SLOTS: fill bits/blind long slots if bit 47 set
  5409. + * @DECT_PT_IT_BLIND_FULL_SLOT: blind full slot information
  5410. + * @DECT_PT_IT_OTHER_BEARER:
  5411. + * @DECT_PT_IT_RECOMMENDED_OTHER_BEARER:
  5412. + * @DECT_PT_IT_GOOD_RFP_BEARER:
  5413. + * @DECT_PT_IT_DUMMY_OR_CL_BEARER_POSITION:
  5414. + * @DECT_PT_IT_RFP_IDENTITY:
  5415. + * @DECT_PT_IT_ESCAPE:
  5416. + * @DECT_PT_IT_DUMMY_OR_CL_BEARER_MARKER:
  5417. + * @DECT_PT_IT_BEARER_HANDOVER_INFO:
  5418. + * @DECT_PT_IT_RFP_STATUS:
  5419. + * @DECT_PT_IT_ACTIVE_CARRIERS:
  5420. + * @DECT_PT_IT_CL_BEARER_POSITION:
  5421. + * @DECT_PT_IT_RECOMMENDED_POWER_LEVEL:
  5422. + * @DECT_PT_IT_BLIND_DOUBLE_SLOT:
  5423. + * @DECT_PT_IT_BLIND_FULL_SLOT_PACKET_MODE:
  5424. + *
  5425. + */
  5426. +enum dect_pt_info_types {
  5427. + DECT_PT_IT_FILL_BITS_OR_BLIND_LONG_SLOTS= 0x0ULL << DECT_PT_INFO_TYPE_SHIFT,
  5428. + DECT_PT_IT_BLIND_FULL_SLOT = 0x1ULL << DECT_PT_INFO_TYPE_SHIFT,
  5429. + DECT_PT_IT_OTHER_BEARER = 0x2ULL << DECT_PT_INFO_TYPE_SHIFT,
  5430. + DECT_PT_IT_RECOMMENDED_OTHER_BEARER = 0x3ULL << DECT_PT_INFO_TYPE_SHIFT,
  5431. + DECT_PT_IT_GOOD_RFP_BEARER = 0x4ULL << DECT_PT_INFO_TYPE_SHIFT,
  5432. + DECT_PT_IT_DUMMY_OR_CL_BEARER_POSITION = 0x5ULL << DECT_PT_INFO_TYPE_SHIFT,
  5433. + DECT_PT_IT_RFP_IDENTITY = 0x6ULL << DECT_PT_INFO_TYPE_SHIFT,
  5434. + DECT_PT_IT_ESCAPE = 0x7ULL << DECT_PT_INFO_TYPE_SHIFT,
  5435. + DECT_PT_IT_DUMMY_OR_CL_BEARER_MARKER = 0x8ULL << DECT_PT_INFO_TYPE_SHIFT,
  5436. + DECT_PT_IT_BEARER_HANDOVER_INFO = 0x9ULL << DECT_PT_INFO_TYPE_SHIFT,
  5437. + DECT_PT_IT_RFP_STATUS = 0xaULL << DECT_PT_INFO_TYPE_SHIFT,
  5438. + DECT_PT_IT_ACTIVE_CARRIERS = 0xbULL << DECT_PT_INFO_TYPE_SHIFT,
  5439. + DECT_PT_IT_CL_BEARER_POSITION = 0xcULL << DECT_PT_INFO_TYPE_SHIFT,
  5440. + DECT_PT_IT_RECOMMENDED_POWER_LEVEL = 0xdULL << DECT_PT_INFO_TYPE_SHIFT,
  5441. + DECT_PT_IT_BLIND_DOUBLE_SLOT = 0xeULL << DECT_PT_INFO_TYPE_SHIFT,
  5442. + DECT_PT_IT_BLIND_FULL_SLOT_PACKET_MODE = 0xfULL << DECT_PT_INFO_TYPE_SHIFT,
  5443. +};
  5444. +
  5445. +/* blind full slot information */
  5446. +#define DECT_PT_BFS_MASK 0x000000000fff0000ULL
  5447. +#define DECT_PT_BFS_SHIFT 16
  5448. +
  5449. +struct dect_bfs {
  5450. + struct dect_page page;
  5451. + u16 mask;
  5452. +};
  5453. +
  5454. +/* Bearer description */
  5455. +#define DECT_PT_BEARER_SN_MASK 0x000000000f000000ULL
  5456. +#define DECT_PT_BEARER_SN_SHIFT 24
  5457. +
  5458. +#define DECT_PT_BEARER_SP_MASK 0x0000000000c00000ULL
  5459. +#define DECT_PT_BEARER_SP_SHIFT 22
  5460. +
  5461. +#define DECT_PT_BEARER_CN_MASK 0x00000000003f0000ULL
  5462. +#define DECT_PT_BEARER_CN_SHIFT 16
  5463. +
  5464. +struct dect_bearer_desc {
  5465. + struct dect_page page;
  5466. + enum dect_pt_info_types bt;
  5467. + u8 sn;
  5468. + u8 sp;
  5469. + u8 cn;
  5470. +};
  5471. +
  5472. +/* RFP identity */
  5473. +#define DECT_PT_RFP_ID_MASK 0x000000000fff0000ULL
  5474. +#define DECT_PT_RFP_ID_SHIFT 16
  5475. +
  5476. +struct dect_rfp_id {
  5477. + struct dect_page page;
  5478. + u16 id;
  5479. +};
  5480. +
  5481. +/* RFP status */
  5482. +#define DECT_PT_RFPS_RFP_BUSY_FLAG 0x0000000001000000ULL
  5483. +#define DECT_PT_RFPS_SYS_BUSY_FLAG 0x0000000002000000ULL
  5484. +
  5485. +struct dect_rfp_status {
  5486. + struct dect_page page;
  5487. + bool rfp_busy;
  5488. + bool sys_busy;
  5489. +};
  5490. +
  5491. +/* Active carriers */
  5492. +#define DECT_PT_ACTIVE_CARRIERS_MASK 0x000000000ffc0000ULL
  5493. +#define DECT_PT_ACTIVE_CARRIERS_SHIFT 18
  5494. +
  5495. +struct dect_active_carriers {
  5496. + struct dect_page page;
  5497. + u16 active;
  5498. +};
  5499. +
  5500. +/*
  5501. + * MAC control (M-channel)
  5502. + */
  5503. +
  5504. +#define DECT_MT_FRAME_RATE 2
  5505. +
  5506. +#define DECT_MT_HDR_MASK 0x00f0000000000000ULL
  5507. +#define DECT_MT_HDR_SHIFT 52
  5508. +
  5509. +#define DECT_MT_CMD_MASK 0x000f000000000000ULL
  5510. +#define DECT_MT_CMD_SHIFT 48
  5511. +
  5512. +/**
  5513. + * enum dect_mt_hdr_type - MAC tail header types
  5514. + */
  5515. +enum dect_mt_hdr_type {
  5516. + DECT_MT_BASIC_CCTRL = 0x0ULL << DECT_MT_HDR_SHIFT,
  5517. + DECT_MT_ADV_CCTRL = 0x1ULL << DECT_MT_HDR_SHIFT,
  5518. + DECT_MT_MAC_TEST = 0x2ULL << DECT_MT_HDR_SHIFT,
  5519. + DECT_MT_QUALITY_CTRL = 0x3ULL << DECT_MT_HDR_SHIFT,
  5520. + DECT_MT_BRD_CL_SERVICE = 0x4ULL << DECT_MT_HDR_SHIFT,
  5521. + DECT_MT_ENC_CTRL = 0x5ULL << DECT_MT_HDR_SHIFT,
  5522. + DECT_MT_XYZ = 0x6ULL << DECT_MT_HDR_SHIFT,
  5523. + DECT_MT_ESC = 0x7ULL << DECT_MT_HDR_SHIFT,
  5524. + DECT_MT_TARI = 0x8ULL << DECT_MT_HDR_SHIFT,
  5525. + DECT_MT_REP_CCTRL = 0x9ULL << DECT_MT_HDR_SHIFT,
  5526. +};
  5527. +
  5528. +/* advanced connection control */
  5529. +enum dect_cctrl_cmds {
  5530. + DECT_CCTRL_ACCESS_REQ = 0x0ULL << DECT_MT_CMD_SHIFT,
  5531. + DECT_CCTRL_BEARER_HANDOVER_REQ = 0x1ULL << DECT_MT_CMD_SHIFT,
  5532. + DECT_CCTRL_CONNECTION_HANDOVER_REQ = 0x2ULL << DECT_MT_CMD_SHIFT,
  5533. + DECT_CCTRL_UNCONFIRMED_ACCESS_REQ = 0x3ULL << DECT_MT_CMD_SHIFT,
  5534. + DECT_CCTRL_BEARER_CONFIRM = 0x4ULL << DECT_MT_CMD_SHIFT,
  5535. + DECT_CCTRL_WAIT = 0x5ULL << DECT_MT_CMD_SHIFT,
  5536. + DECT_CCTRL_ATTRIBUTES_T_REQUEST = 0x6ULL << DECT_MT_CMD_SHIFT,
  5537. + DECT_CCTRL_ATTRIBUTES_T_CONFIRM = 0x7ULL << DECT_MT_CMD_SHIFT,
  5538. + DECT_CCTRL_BANDWIDTH_T_REQUEST = 0x8ULL << DECT_MT_CMD_SHIFT,
  5539. + DECT_CCTRL_BANDWIDTH_T_CONFIRM = 0x9ULL << DECT_MT_CMD_SHIFT,
  5540. + DECT_CCTRL_CHANNEL_LIST = 0xaULL << DECT_MT_CMD_SHIFT,
  5541. + DECT_CCTRL_UNCONFIRMED_DUMMY = 0xbULL << DECT_MT_CMD_SHIFT,
  5542. + DECT_CCTRL_UNCONFIRMED_HANDOVER = 0xcULL << DECT_MT_CMD_SHIFT,
  5543. + DECT_CCTRL_RELEASE = 0xfULL << DECT_MT_CMD_SHIFT,
  5544. +};
  5545. +
  5546. +/* Most messages */
  5547. +#define DECT_CCTRL_FMID_MASK 0x0000fff000000000ULL
  5548. +#define DECT_CCTRL_FMID_SHIFT 36
  5549. +
  5550. +#define DECT_CCTRL_PMID_MASK 0x0000000fffff0000ULL
  5551. +#define DECT_CCTRL_PMID_SHIFT 16
  5552. +
  5553. +/* Attributes-T request/confirm */
  5554. +#define DECT_CCTRL_ATTR_ECN_MASK 0x0000f00000000000ULL
  5555. +#define DECT_CCTRL_ATTR_ECN_SHIFT 44
  5556. +
  5557. +#define DECT_CCTRL_ATTR_LBN_MASK 0x00000f0000000000ULL
  5558. +#define DECT_CCTRL_ATTR_LBN_SHIFT 40
  5559. +
  5560. +#define DECT_CCTRL_ATTR_TYPE_MASK 0x000000c000000000ULL
  5561. +#define DECT_CCTRL_ATTR_TYPE_SHIFT 38
  5562. +
  5563. +enum dect_cctrl_connection_types {
  5564. + DECT_CCTRL_TYPE_ASYMETRIC_UPLINK = 0x0,
  5565. + DECT_CCTRL_TYPE_ASYMETRIC_DOWNLINK = 0x1,
  5566. + DECT_CCTRL_TYPE_SYMETRIC_MULTIBEARER = 0x2,
  5567. + DECT_CCTRL_TYPE_SYMETRIC_BEARER = 0x3,
  5568. +};
  5569. +
  5570. +#define DECT_CCTRL_ATTR_SERVICE_MASK 0x0000003f00000000ULL
  5571. +#define DECT_CCTRL_ATTR_SERVICE_SHIFT 32
  5572. +
  5573. +#define DECT_CCTRL_ATTR_SLOT_MASK 0x00000000f0000000ULL
  5574. +#define DECT_CCTRL_ATTR_SLOT_SHIFT 28
  5575. +
  5576. +#define DECT_CCTRL_ATTR_CF_FLAG 0x0000000008000000ULL
  5577. +
  5578. +#define DECT_CCTRL_ATTR_BZ_EXT_MOD_MASK 0x0000000007000000ULL
  5579. +#define DECT_CCTRL_ATTR_BZ_EXT_MOD_SHIFT 24
  5580. +
  5581. +#define DECT_CCTRL_ATTR_ACR_MASK 0x0000000000f00000ULL
  5582. +#define DECT_CCTRL_ATTR_ACR_SHIFT 20
  5583. +
  5584. +enum dect_adaptive_code_rates {
  5585. + DECT_ACR_NONE = 0x0,
  5586. +};
  5587. +
  5588. +#define DECT_CCTRL_ATTR_A_MOD_MASK 0x00000000000c0000ULL
  5589. +#define DECT_CCTRL_ATTR_A_MOD_SHIFT 18
  5590. +
  5591. +#define DECT_CCTRL_ATTR_BZ_MOD_MASK 0x0000000000030000ULL
  5592. +#define DECT_CCTRL_ATTR_BZ_MOD_SHIFT 16
  5593. +
  5594. +enum dect_modulation_type {
  5595. + DECT_MODULATION_2_LEVEL = 0x3,
  5596. + DECT_MODULATION_4_LEVEL = 0x2,
  5597. + DECT_MODULATION_8_LEVEL = 0x1,
  5598. +};
  5599. +
  5600. +/* Release */
  5601. +
  5602. +#define DECT_CCTRL_RELEASE_INFO1_MASK 0x0000f00000000000ULL
  5603. +#define DECT_CCTRL_RELEASE_INFO1_SHIFT 44
  5604. +
  5605. +#define DECT_CCTRL_RELEASE_LBN_MASK 0x00000f0000000000ULL
  5606. +#define DECT_CCTRL_RELEASE_LBN_SHIFT 40
  5607. +
  5608. +#define DECT_CCTRL_RELEASE_REASON_MASK 0x000000f000000000ULL
  5609. +#define DECT_CCTRL_RELEASE_REASON_SHIFT 36
  5610. +
  5611. +enum dect_release_reasons {
  5612. + DECT_REASON_UNKNOWN = 0x0,
  5613. + DECT_REASON_BEARER_RELEASE = 0x1,
  5614. + DECT_REASON_CONNECTION_RELEASE = 0x2,
  5615. + DECT_REASON_BEARER_SETUP_OR_HANDOVER_FAILED = 0x3,
  5616. + DECT_REASON_BEARER_HANDOVER_COMPLETED = 0x4,
  5617. + DECT_REASON_BEARER_HANDOVER_CLUSTER = 0x5,
  5618. + DECT_REASON_TIMEOUT_LOST_SIGNAL = 0x6,
  5619. + DECT_REASON_TIMEOUT_LOST_HANDSHAKE = 0x7,
  5620. + DECT_REASON_REQUESTED_UNACCEPTABLE_SLOT_TYPE = 0x8,
  5621. + DECT_REASON_REQUESTED_UNACCEPTABLE_MAC_SERVICE = 0x9,
  5622. + DECT_REASON_BASE_STATION_BUSY = 0xa,
  5623. + DECT_REASON_REVERSE_DIRECTION = 0xb,
  5624. + DECT_REASON_DUPLICATE_PMID = 0xc,
  5625. + DECT_REASON_UNACCEPTABLE_PMID = 0xd,
  5626. + DECT_REASON_STAY_ON_LISTEN = 0xe,
  5627. +};
  5628. +
  5629. +#define DECT_CCTRL_RELEASE_PMID_MASK 0x0000000fffff0000ULL
  5630. +#define DECT_CCTRL_RELEASE_PMID_SHIFT 16
  5631. +
  5632. +struct dect_cctrl {
  5633. + enum dect_cctrl_cmds cmd;
  5634. + u16 fmid;
  5635. + u32 pmid;
  5636. + union {
  5637. + struct {
  5638. + u8 lbn;
  5639. + u8 ecn;
  5640. + u8 type;
  5641. + u8 service;
  5642. + u8 slot;
  5643. + bool cf;
  5644. + u8 a_mod;
  5645. + u8 bz_mod;
  5646. + u8 bz_ext_mod;
  5647. + u8 acr;
  5648. + } attr;
  5649. + struct {
  5650. + u8 lbn;
  5651. + u8 reason;
  5652. + } rel;
  5653. + };
  5654. +};
  5655. +
  5656. +/* Encryption Control */
  5657. +
  5658. +#define DECT_ENCCTRL_FILL_MASK 0x0050000000000000ULL
  5659. +
  5660. +#define DECT_ENCCTRL_CMD_MASK 0x000f000000000000ULL
  5661. +#define DECT_ENCCTRL_CMD_SHIFT 48
  5662. +
  5663. +enum dect_encctrl_cmds {
  5664. + DECT_ENCCTRL_START_REQUEST = 0x0,
  5665. + DECT_ENCCTRL_START_CONFIRM = 0x1,
  5666. + DECT_ENCCTRL_START_GRANT = 0x2,
  5667. + DECT_ENCCTRL_STOP_REQUEST = 0x4,
  5668. + DECT_ENCCTRL_STOP_CONFIRM = 0x5,
  5669. + DECT_ENCCTRL_STOP_GRANT = 0x6,
  5670. +};
  5671. +
  5672. +#define DECT_ENCCTRL_FMID_MASK 0x0000fff000000000ULL
  5673. +#define DECT_ENCCTRL_FMID_SHIFT 36
  5674. +
  5675. +#define DECT_ENCCTRL_PMID_MASK 0x0000000fffff0000ULL
  5676. +#define DECT_ENCCTRL_PMID_SHIFT 16
  5677. +
  5678. +struct dect_encctrl {
  5679. + enum dect_encctrl_cmds cmd;
  5680. + u32 pmid;
  5681. + u16 fmid;
  5682. +};
  5683. +
  5684. +/* marker for T-MUX exceptions */
  5685. +#define DECT_MT_HIGH_PRIORITY 0x1
  5686. +
  5687. +/*
  5688. + * C_T data
  5689. + */
  5690. +
  5691. +#define DECT_C_S_SDU_SIZE 5
  5692. +
  5693. +struct dect_ct_data {
  5694. + u8 seq;
  5695. +};
  5696. +
  5697. +/*
  5698. + * Flat representation of tail message contents
  5699. + */
  5700. +enum dect_tail_msg_types {
  5701. + DECT_TM_TYPE_INVALID,
  5702. + DECT_TM_TYPE_ID,
  5703. + DECT_TM_TYPE_SSI,
  5704. + DECT_TM_TYPE_ERFC,
  5705. + DECT_TM_TYPE_FPC,
  5706. + DECT_TM_TYPE_EFPC,
  5707. + DECT_TM_TYPE_EFPC2,
  5708. + DECT_TM_TYPE_SARI,
  5709. + DECT_TM_TYPE_MFN,
  5710. + DECT_TM_TYPE_PAGE,
  5711. + DECT_TM_TYPE_BFS,
  5712. + DECT_TM_TYPE_BD,
  5713. + DECT_TM_TYPE_RFP_ID,
  5714. + DECT_TM_TYPE_RFP_STATUS,
  5715. + DECT_TM_TYPE_ACTIVE_CARRIERS,
  5716. + DECT_TM_TYPE_BCCTRL,
  5717. + DECT_TM_TYPE_ACCTRL,
  5718. + DECT_TM_TYPE_ENCCTRL,
  5719. + DECT_TM_TYPE_CT,
  5720. +};
  5721. +
  5722. +struct dect_tail_msg {
  5723. + enum dect_tail_identifications ti;
  5724. + enum dect_tail_msg_types type;
  5725. + union {
  5726. + struct dect_idi idi;
  5727. + struct dect_ssi ssi;
  5728. + struct dect_erfc erfc;
  5729. + struct dect_fpc fpc;
  5730. + struct dect_efpc efpc;
  5731. + struct dect_efpc2 efpc2;
  5732. + struct dect_sari sari;
  5733. + struct dect_mfn mfn;
  5734. + struct dect_page page;
  5735. + struct dect_bfs bfs;
  5736. + struct dect_bearer_desc bd;
  5737. + struct dect_rfp_id rfp_id;
  5738. + struct dect_rfp_status rfp_status;
  5739. + struct dect_active_carriers active_carriers;
  5740. + struct dect_cctrl cctl;
  5741. + struct dect_encctrl encctl;
  5742. + struct dect_ct_data ctd;
  5743. + };
  5744. +};
  5745. +
  5746. +struct dect_si {
  5747. + u32 mask;
  5748. + struct dect_ssi ssi;
  5749. + struct dect_erfc erfc;
  5750. + struct dect_fpc fpc;
  5751. + struct dect_efpc efpc;
  5752. + struct dect_efpc2 efpc2;
  5753. + struct dect_sari sari[DECT_SARI_CYCLE_MAX];
  5754. + struct dect_mfn mfn;
  5755. + u8 num_saris;
  5756. +};
  5757. +
  5758. +/*
  5759. + * B-Field
  5760. + */
  5761. +
  5762. +/**
  5763. + * dect_b_identitifications - MAC layer B-Field Identification
  5764. + *
  5765. + * @DECT_BI_UTYPE_0: U-Type, I_N, SI_N, SI_P or I_P packet number 0
  5766. + * @DECT_BI_UTYPE_1: U-Type, I_P error detect or I_P packet number 1
  5767. + * @DECT_BI_ETYPE_CF_0: E-Type, all C_F or CL_F, packet number 0
  5768. + * @DECT_BI_ETYPE_CF_1: E-Type, all C_F, packet number 1
  5769. + * @DECT_BI_ETYPE_MAC: E-Type, all MAC control (unnumbered)
  5770. + * @DECT_BI_NONE: no B-Field
  5771. + */
  5772. +enum dect_b_identifications {
  5773. + DECT_BI_UTYPE_0 = 0x0 << DECT_HDR_BA_SHIFT,
  5774. + DECT_BI_UTYPE_1 = 0x1 << DECT_HDR_BA_SHIFT,
  5775. + DECT_BI_ETYPE_CF_0 = 0x2 << DECT_HDR_BA_SHIFT,
  5776. + DECT_BI_DOUBLE_SLOT_REQUIRED = DECT_BI_ETYPE_CF_0,
  5777. + DECT_BI_ETYPE_CF_1 = 0x3 << DECT_HDR_BA_SHIFT,
  5778. + DECT_BI_ETYPE_NOT_ALL_CF_0 = 0x4 << DECT_HDR_BA_SHIFT,
  5779. + DECT_BI_HALF_SLOT_REQUIRED = DECT_BI_ETYPE_NOT_ALL_CF_0,
  5780. + DECT_BI_ETYPE_NOT_ALL_CF_1 = 0x5 << DECT_HDR_BA_SHIFT,
  5781. + DECT_BI_LONG_SLOT_640_REQUIRED = DECT_BI_ETYPE_NOT_ALL_CF_1,
  5782. + DECT_BI_ETYPE_MAC = 0x6 << DECT_HDR_BA_SHIFT,
  5783. + DECT_BI_LONG_SLOT_672_REQUIRED = DECT_BI_ETYPE_MAC,
  5784. + DECT_BI_NONE = 0x7 << DECT_HDR_BA_SHIFT,
  5785. +};
  5786. +
  5787. +struct dect_skb_b_cb {
  5788. + enum dect_b_identifications id;
  5789. +};
  5790. +
  5791. +#define DECT_B_CB(skb) ((struct dect_skb_b_cb *)(skb)->cb)
  5792. +
  5793. +#define DECT_C_F_SDU_SIZE 8
  5794. +#define DECT_G_F_SDU_SIZE 8
  5795. +
  5796. +/**
  5797. + * enum dect_mac_channels - internal MAC control channels
  5798. + *
  5799. + * @DECT_MC_Q: System information and multiframe marker
  5800. + * @DECT_MC_N: Identities information
  5801. + * @DECT_MC_M: MAC control channel
  5802. + * @DECT_MC_P: MAC Paging channel
  5803. + */
  5804. +enum dect_mac_channels {
  5805. + DECT_MC_Q,
  5806. + DECT_MC_N,
  5807. + DECT_MC_M,
  5808. + DECT_MC_P,
  5809. +};
  5810. +
  5811. +/**
  5812. + * enum dect_data_channels - logical MAC data channels
  5813. + *
  5814. + * @DECT_MC_G_F:
  5815. + * @DECT_MC_C_S: Higher layer C-Plane channel (slow)
  5816. + * @DECT_MC_C_F: Higher layer C-Plane channel (fast)
  5817. + * @DECT_MC_I_N: Higher layer U-Plane channel (numbered)
  5818. + * @DECT_MC_I_P: Higher layer U-Plane channel (protected)
  5819. + * @DECT_MC_SI_N: Higher layer connectionless U-Plane channel (numbered)
  5820. + * @DECT_MC_SI_P: Higher layer connectionless U-Plane channel (protected)
  5821. + */
  5822. +enum dect_data_channels {
  5823. + DECT_MC_G_F,
  5824. + DECT_MC_C_S,
  5825. + DECT_MC_C_F,
  5826. + DECT_MC_I_N,
  5827. + DECT_MC_I_P,
  5828. + DECT_MC_SI_N,
  5829. + DECT_MC_SI_P,
  5830. + __DECT_MC_MAX
  5831. +};
  5832. +#define DECT_MC_MAX (__DECT_MC_MAX - 1)
  5833. +
  5834. +/**
  5835. + * struct dect_tbc_id
  5836. + *
  5837. + * @ari: FT identifier
  5838. + * @pmid: Portable MAC identity
  5839. + * @lbn: Logical Bearer Number
  5840. + * @enc: Exchanged connection number
  5841. + * @tbei: Traffic Bearer Endpoint Identifier
  5842. + */
  5843. +struct dect_tbc_id {
  5844. + struct dect_ari ari;
  5845. + struct dect_pmid pmid;
  5846. + u8 lbn;
  5847. + u8 ecn;
  5848. + u32 tbei;
  5849. +};
  5850. +
  5851. +/**
  5852. + * struct dect_mbc_id
  5853. + *
  5854. + * @mcei: MAC Connection Endpoint Identifier
  5855. + * @ari: FT identifier
  5856. + * @pmid: Portable MAC Identity
  5857. + * @ecn: Exchanged Connection Number
  5858. + * @service: Service type
  5859. + */
  5860. +struct dect_mbc_id {
  5861. + u32 mcei;
  5862. + struct dect_ari ari;
  5863. + struct dect_pmid pmid;
  5864. + u8 ecn;
  5865. +};
  5866. +
  5867. +#endif /* _NET_DECT_MAC_H */
  5868. diff --git a/include/net/dect/mac_ccf.h b/include/net/dect/mac_ccf.h
  5869. new file mode 100644
  5870. index 0000000..31ba6ab
  5871. --- /dev/null
  5872. +++ b/include/net/dect/mac_ccf.h
  5873. @@ -0,0 +1,251 @@
  5874. +/*
  5875. + * DECT MAC Layer - Cluster Control Functions (CCF)
  5876. + *
  5877. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  5878. + */
  5879. +
  5880. +#ifndef _NET_DECT_MAC_CCF_H
  5881. +#define _NET_DECT_MAC_CCF_H
  5882. +
  5883. +#include <linux/skbuff.h>
  5884. +#include <linux/timer.h>
  5885. +#include <net/dect/mac.h>
  5886. +
  5887. +/**
  5888. + * struct dect_bmc_skb_cb
  5889. + *
  5890. + * @fast_page: page message is a fast page
  5891. + * @long_page: page message is a long page
  5892. + * @stamp: multiframe number at time of TX request
  5893. + * @repetitions: number of page repetitions
  5894. + */
  5895. +struct dect_bmc_skb_cb {
  5896. + bool fast_page;
  5897. + bool long_page;
  5898. + u32 stamp;
  5899. + u8 repetitions;
  5900. +};
  5901. +#define DECT_BMC_CB(skb) ((struct dect_bmc_skb_cb *)(skb)->cb)
  5902. +
  5903. +#define DECT_PAGE_LIFETIME 6 /* multiframes */
  5904. +
  5905. +/**
  5906. + * struct dect_bmc - broadcast message control
  5907. + *
  5908. + * @bcs: broadcast controller list
  5909. + * @index: system information round robin index
  5910. + */
  5911. +struct dect_bmc {
  5912. + struct list_head bcs;
  5913. + unsigned int index;
  5914. +};
  5915. +
  5916. +struct dect_cmc {
  5917. +
  5918. +};
  5919. +
  5920. +struct dect_cs_skb_cb {
  5921. + u8 seq;
  5922. +};
  5923. +#define DECT_CS_CB(skb) ((struct dect_cs_skb_cb *)(skb)->cb)
  5924. +
  5925. +/**
  5926. + * struct dect_tb - DECT Traffic Bearer
  5927. + *
  5928. + * @list: MBC traffic bearer list node
  5929. + * @mbc: MBC controlling the traffic bearer
  5930. + * @ch: Cell handling the traffic bearer
  5931. + * @id: Traffic Bearer Controller ID
  5932. + * @handover: Handover yes/no
  5933. + * @handover_timer: Handover timer
  5934. + * @rx_slot: Receive slot
  5935. + * @tx_slot: Transmit slot
  5936. + * @slot_rx_timer: Receive slot timer
  5937. + * @slot_tx_timer: Transmit slot timer
  5938. + * @b_rx_skb: B-Field receive skb
  5939. + */
  5940. +struct dect_tb {
  5941. + struct list_head list;
  5942. + struct dect_mbc *mbc;
  5943. + const struct dect_cell_handle *ch;
  5944. + struct dect_tbc_id id;
  5945. + bool handover;
  5946. +
  5947. + /* FP: handover release timer */
  5948. + struct dect_timer handover_timer;
  5949. +
  5950. + /* Slot transmit/receive timers */
  5951. + u8 rx_slot;
  5952. + u8 tx_slot;
  5953. + struct dect_timer slot_rx_timer;
  5954. + struct dect_timer slot_tx_timer;
  5955. +
  5956. + /* I channel data */
  5957. + struct sk_buff *b_rx_skb;
  5958. +};
  5959. +
  5960. +struct dect_mbc_stats {
  5961. + unsigned int cs_rx_bytes;
  5962. + unsigned int cs_tx_bytes;
  5963. + unsigned int i_rx_bytes;
  5964. + unsigned int i_tx_bytes;
  5965. + unsigned int handovers;
  5966. +};
  5967. +
  5968. +/**
  5969. + * struct dect_mbc - DECT Multi-Bearer Control
  5970. + *
  5971. + * @list: Cluster connection list node
  5972. + * @cl: Cluster the MBC is contained in
  5973. + * @refcnt: Reference count
  5974. + * @id: MBC identity
  5975. + * @state: MBC state
  5976. + * @timer: Connection setup timer (T200)
  5977. + * @setup_cnt: number of setup attempts (N200)
  5978. + * @tbs: List of traffic bearers
  5979. + * @ho_stamp: Handover token bucket refill timestamp
  5980. + * @ho_tokens: Handover token bucket tokens
  5981. + * @normal_rx_timer: Normal receive half frame timer
  5982. + * @onrmal_tx_timer: Normal transmit half frame timer
  5983. + * @ck: Cipher key
  5984. + * @cipher_state: Ciphering state
  5985. + * @cs_rx_seq: C_S receive sequence number
  5986. + * @cs_tx_seq: C_S transmit sequence number
  5987. + * @cs_tx_ok: C_S segment transmit OK
  5988. + * @cs_rx_ok: C_S segment reception OK
  5989. + * @cs_tx_skb: C_S segment queued for transmission
  5990. + * @cs_tx_skb: C_S segment queued for delivery to DLC
  5991. + */
  5992. +struct dect_mbc {
  5993. + struct list_head list;
  5994. + struct dect_cluster *cl;
  5995. + unsigned int refcnt;
  5996. +
  5997. + struct dect_mbc_id id;
  5998. + struct dect_mac_conn_params mcp;
  5999. + enum dect_mbc_state state;
  6000. +
  6001. + struct timer_list timer;
  6002. + u8 setup_cnt;
  6003. +
  6004. + struct list_head tbs;
  6005. +
  6006. + /* Handover rate limiting */
  6007. + unsigned long ho_stamp;
  6008. + u8 ho_tokens;
  6009. +
  6010. + /* Normal transmit/receive timers */
  6011. + struct dect_timer normal_rx_timer;
  6012. + struct dect_timer normal_tx_timer;
  6013. +
  6014. + /* Encryption */
  6015. + u64 ck;
  6016. + enum dect_cipher_states cipher_state;
  6017. +
  6018. + /* C_S channel */
  6019. + u8 cs_rx_seq;
  6020. + u8 cs_tx_seq;
  6021. + bool cs_tx_ok;
  6022. + bool cs_rx_ok;
  6023. + struct sk_buff *cs_rx_skb;
  6024. + struct sk_buff *cs_tx_skb;
  6025. +
  6026. + struct dect_mbc_stats stats;
  6027. +};
  6028. +
  6029. +#define DECT_MBC_SETUP_TIMEOUT (5 * HZ) /* T200: 5 seconds */
  6030. +#define DECT_MBC_SETUP_MAX_ATTEMPTS 10 /* N200: 10 attempts */
  6031. +#define DECT_MBC_HANDOVER_TIMER (3 * HZ) /* T202: 3 seconds */
  6032. +#define DECT_MBC_TB_HANDOVER_TIMEOUT 16 /* T203: 16 frames */
  6033. +
  6034. +#define DECT_MBC_HANDOVER_LIMIT 2 /* per N202 seconds */
  6035. +#define DECT_MBC_HANDOVER_REATTEMPTS 15 /* N201: 15 */
  6036. +
  6037. +extern u32 dect_mbc_alloc_mcei(struct dect_cluster *cl);
  6038. +extern int dect_mac_con_req(struct dect_cluster *cl,
  6039. + const struct dect_mbc_id *id,
  6040. + const struct dect_mac_conn_params *mcp);
  6041. +extern void dect_mac_dis_req(struct dect_cluster *cl, u32 mcei);
  6042. +
  6043. +extern int dect_mac_enc_key_req(const struct dect_cluster *cl, u32 mcei, u64 ck);
  6044. +extern int dect_mac_enc_eks_req(const struct dect_cluster *cl, u32 mcei,
  6045. + enum dect_cipher_states status);
  6046. +
  6047. +extern void dect_bmc_mac_page_req(struct dect_cluster *cl, struct sk_buff *skb);
  6048. +
  6049. +extern u8 dect_b_field_size(enum dect_slot_types slot);
  6050. +
  6051. +struct dect_llme_req;
  6052. +
  6053. +/**
  6054. + * struct dect_ccf_ops - Cluster Control Ops
  6055. + *
  6056. + * @bind: bind cell to cluster
  6057. + * @unbind: unbind cell from cluster
  6058. + * @mac_info_indicate: indicate FP mac layer information (PP only)
  6059. + * @mbc_conn_indicate: indicate a new TBC connection
  6060. + * @mbc_conn_notify: notify MBC of TBC events
  6061. + * @mbc_data_indicate: indicate new data to MBC
  6062. + * @bmc_page_indicate: indicate reception of a page message to the BMC
  6063. + */
  6064. +struct dect_cluster_handle;
  6065. +struct dect_scan_result;
  6066. +enum dect_tbc_event;
  6067. +struct dect_ccf_ops {
  6068. + int (*bind)(struct dect_cluster_handle *,
  6069. + struct dect_cell_handle *);
  6070. + void (*unbind)(struct dect_cluster_handle *,
  6071. + struct dect_cell_handle *);
  6072. +
  6073. + void (*time_ind)(struct dect_cluster_handle *,
  6074. + enum dect_timer_bases, u32, u8, u8);
  6075. +
  6076. + void (*scan_report)(const struct dect_cluster_handle *,
  6077. + const struct dect_scan_result *);
  6078. +
  6079. + void (*mac_info_ind)(const struct dect_cluster_handle *,
  6080. + const struct dect_idi *,
  6081. + const struct dect_si *);
  6082. +
  6083. + int (*tbc_establish_ind)(const struct dect_cluster_handle *,
  6084. + const struct dect_cell_handle *,
  6085. + const struct dect_tbc_id *,
  6086. + const struct dect_mac_conn_params *, bool);
  6087. + int (*tbc_establish_cfm)(const struct dect_cluster_handle *,
  6088. + const struct dect_tbc_id *, bool, u8);
  6089. + void (*tbc_dis_ind)(const struct dect_cluster_handle *,
  6090. + const struct dect_tbc_id *,
  6091. + enum dect_release_reasons);
  6092. + int (*tbc_event_ind)(const struct dect_cluster_handle *,
  6093. + const struct dect_tbc_id *,
  6094. + enum dect_tbc_event);
  6095. + void (*tbc_data_ind)(const struct dect_cluster_handle *,
  6096. + const struct dect_tbc_id *,
  6097. + enum dect_data_channels chan,
  6098. + struct sk_buff *);
  6099. + int (*tbc_handover_req)(const struct dect_cluster_handle *,
  6100. + const struct dect_tbc_id *);
  6101. +
  6102. + void (*bmc_page_ind)(const struct dect_cluster_handle *,
  6103. + struct sk_buff *);
  6104. +};
  6105. +
  6106. +/**
  6107. + * struct dect_cluster_handle - Cell's view of a cluster
  6108. + *
  6109. + * @ops: Cluster Control Function ops
  6110. + * @index: Cluster index
  6111. + * @tipc_id: Cluster TIPC user ID
  6112. + * @tportref: Topology Service port reference (remote cluster only)
  6113. + * @portref: Cell Control Protocol port reference (remote cluster only)
  6114. + */
  6115. +struct dect_cluster_handle {
  6116. + const struct dect_ccf_ops *ops;
  6117. + u8 index;
  6118. +
  6119. + u32 tipc_id;
  6120. + u32 tportref;
  6121. + u32 portref;
  6122. +};
  6123. +
  6124. +#endif /* _NET_DECT_MAC_CCF_H */
  6125. diff --git a/include/net/dect/mac_csf.h b/include/net/dect/mac_csf.h
  6126. new file mode 100644
  6127. index 0000000..301fdc1
  6128. --- /dev/null
  6129. +++ b/include/net/dect/mac_csf.h
  6130. @@ -0,0 +1,604 @@
  6131. +/*
  6132. + * DECT MAC Layer - Cell Site Functions (CSF)
  6133. + *
  6134. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  6135. + */
  6136. +
  6137. +#ifndef _NET_DECT_MAC_CSF_H
  6138. +#define _NET_DECT_MAC_CSF_H
  6139. +
  6140. +#include <net/dect/mac.h>
  6141. +#include <net/dect/transceiver.h>
  6142. +#define DECT_CHANNEL_LIST_DBM_RES 6
  6143. +#define DECT_CHANNEL_LIST_BINS (DECT_RSSI_DBM_RANGE / DECT_CHANNEL_LIST_DBM_RES)
  6144. +
  6145. +/**
  6146. + * struct dect_channel_list_entry
  6147. + *
  6148. + * @list: channel list bin node
  6149. + * @slot: slot number
  6150. + * @carrier: RF-carrier
  6151. + * @rssi: measured RSSI value
  6152. + */
  6153. +struct dect_channel_list_entry {
  6154. + struct list_head list;
  6155. + u8 slot;
  6156. + u8 carrier;
  6157. + u8 rssi;
  6158. +};
  6159. +
  6160. +/**
  6161. + * struct dect_channel_list - Basic channel list
  6162. + *
  6163. + * @list: cell's channel lists list node
  6164. + * @pkt: packet type used for RSSI measurement
  6165. + * @status: bitmask of completed carriers
  6166. + * @timer: update timer
  6167. + * @available: number of available entries
  6168. + * @bins: channels ordered by RSSI value
  6169. + * @entries: channel list entries
  6170. + *
  6171. + * A channel list contains channel descriptions of all physical channels
  6172. + * able to carry the packet type, sorted into multiple bins based on the
  6173. + * maximum RSSI value of the TDD slot pair.
  6174. + */
  6175. +struct dect_channel_list {
  6176. + struct list_head list;
  6177. + enum dect_packet_types pkt;
  6178. + u64 status;
  6179. +
  6180. + struct dect_timer timer;
  6181. + u16 available;
  6182. + struct list_head bins[DECT_CHANNEL_LIST_BINS];
  6183. + struct dect_channel_list_entry entries[];
  6184. +};
  6185. +
  6186. +#define DECT_CHANNEL_LIST_MAX_AGE 30 /* T209: 30 seconds */
  6187. +#define DECT_CHANNEL_LIST_MAX_DBM -50 /* dBm */
  6188. +#define DECT_CHANNEL_LIST_LOW_WATERMARK 20 /* channels */
  6189. +
  6190. +#define DECT_CHANNEL_MIN_DELAY 2 /* frames */
  6191. +
  6192. +enum dect_bearer_states {
  6193. + DECT_DUMMY_BEARER,
  6194. + DECT_TRAFFIC_BEARER,
  6195. + DECT_CL_BEARER,
  6196. + DECT_MONITOR_BEARER,
  6197. +};
  6198. +
  6199. +enum dect_bearer_modes {
  6200. + DECT_BEARER_RX,
  6201. + DECT_BEARER_TX,
  6202. +};
  6203. +
  6204. +/**
  6205. + * enum dect_bearer_state - DECT MAC bearer states
  6206. + *
  6207. + * @DECT_BEARER_INACTIVE: bearer inactive
  6208. + * @DECT_BEARER_SCHEDULED: bearer is scheduled for activation
  6209. + * @DECT_BEARER_RSSI_CONFIRM: bearer is scheduled for RSSI confirmation
  6210. + * @DECT_BEARER_RSSI_CONFIRMED: RSSI is confirmed, bearer is scheduled for e
  6211. + * @DECT_BEARER_ENABLED: bearer is enabled
  6212. + */
  6213. +enum dect_bearer_state {
  6214. + DECT_BEARER_INACTIVE,
  6215. + DECT_BEARER_SCHEDULED,
  6216. + DECT_BEARER_RSSI_CONFIRM,
  6217. + DECT_BEARER_RSSI_CONFIRMED,
  6218. + DECT_BEARER_ENABLED,
  6219. +};
  6220. +
  6221. +struct dect_bearer;
  6222. +struct dect_bearer_ops {
  6223. + enum dect_bearer_states state;
  6224. + void (*enable)(struct dect_cell *, struct dect_bearer *);
  6225. + void (*report_rssi)(struct dect_cell *, struct dect_bearer *,
  6226. + u8 slot, u8 rssi);
  6227. + void (*rcv)(struct dect_cell *cell, struct dect_bearer *,
  6228. + struct sk_buff *);
  6229. +};
  6230. +
  6231. +/**
  6232. + * struct dect_bearer - DECT MAC Bearer
  6233. + *
  6234. + * @type: bearer type
  6235. + * @state: operational state
  6236. + * @trx: DECT transceiver
  6237. + * @chd: channel description
  6238. + * @mode: bearer mode (RX/TX)
  6239. + * @tx_timer: TX enable timer
  6240. + * @rssi: last measured RSSI of selected channel
  6241. + * @m_tx_queue: M-channel TX queue
  6242. + * @q: Hdr-field MUX for Q1/Q2 bit settings
  6243. + * @union: bearer type specific data
  6244. + */
  6245. +struct dect_bearer {
  6246. + const struct dect_bearer_ops *ops;
  6247. + struct dect_transceiver *trx;
  6248. + struct dect_channel_desc chd;
  6249. + enum dect_bearer_modes mode;
  6250. + enum dect_bearer_state state;
  6251. + struct dect_timer tx_timer;
  6252. + u8 rssi;
  6253. +
  6254. + struct sk_buff_head m_tx_queue;
  6255. + u8 q;
  6256. +
  6257. + union {
  6258. + struct dect_dbc *dbc;
  6259. + struct dect_cbc *cbc;
  6260. + struct dect_tbc *tbc;
  6261. + struct dect_dmb *dmb;
  6262. + struct dect_irc *irc;
  6263. + void *data;
  6264. + };
  6265. +};
  6266. +
  6267. +/**
  6268. + * struct dect_bc - broadcast controller
  6269. + *
  6270. + * @list: broadcast message control BC list node
  6271. + * @p_rx_skb: current RX P-channel message
  6272. + * @p_tx_mask: bitmask of scheduled mac layer pages
  6273. + */
  6274. +struct dect_bc {
  6275. + struct list_head list;
  6276. + struct sk_buff *p_rx_skb;
  6277. + u32 p_tx_mask;
  6278. +};
  6279. +
  6280. +/*
  6281. + * enum dect_bearer_qctrl_state - DECT bearer quality control state
  6282. + *
  6283. + * @DECT_BEARER_QCTRL_WAIT: waiting for next quality control event
  6284. + * @DECT_BEARER_QCTRL_CONFIRM: performing quality control
  6285. + */
  6286. +enum dect_bearer_qctrl_state {
  6287. + DECT_BEARER_QCTRL_WAIT,
  6288. + DECT_BEARER_QCTRL_CONFIRM,
  6289. +};
  6290. +
  6291. +#define DECT_BEARER_QCTRL_FRAMENUM 15 /* must not affect paging */
  6292. +#define DECT_BEARER_QCTRL_PERIOD 256 /* frames */
  6293. +
  6294. +/**
  6295. + * struct dect_dbc - dummy bearer control
  6296. + *
  6297. + * @list: cell dbc list node
  6298. + * @cell: DECT cell
  6299. + * @bearer: dummy bearer
  6300. + * @qctrl_timer: quality control timer
  6301. + * @qctrl_state: qaulity control state
  6302. + * @bc: broadcast controller
  6303. + */
  6304. +struct dect_dbc {
  6305. + struct list_head list;
  6306. + struct dect_cell *cell;
  6307. + struct dect_bearer bearer;
  6308. + struct dect_timer qctrl_timer;
  6309. + enum dect_bearer_qctrl_state qctrl;
  6310. + struct dect_bc bc;
  6311. +};
  6312. +
  6313. +/*
  6314. + * struct dect_cbc - connectionless bearer control
  6315. + *
  6316. + * @cell: DECT cell
  6317. + * @dl_bearer: connectionless downlink bearer
  6318. + * @ul_bearer: connectionless uplink bearer, if present
  6319. + * @bc: broadcast controller
  6320. + */
  6321. +struct dect_cbc {
  6322. + struct dect_cell *cell;
  6323. + struct dect_bearer dl_bearer;
  6324. + struct dect_bearer ul_bearer;
  6325. + struct dect_bc bc;
  6326. +};
  6327. +
  6328. +/**
  6329. + * enum dect_tbc_state - DECT Traffic Bearer Controller state
  6330. + *
  6331. + * @DECT_TBC_NONE: Initial state
  6332. + * @DECT_TBC_REQ_SENT: Initiator: bearer request sent
  6333. + * @DECT_TBC_WAIT_RCVD: Initiator: intermediate state
  6334. + * @DECT_TBC_REQ_RCVD: Responder: request received
  6335. + * @DECT_TBC_RESPONSE_SENT: Responder: immediate response to request sent
  6336. + * @DECT_TBC_ATTRIBUTES_SENT: Initiator: attributes-T request sent
  6337. + * @DECT_TBC_OTHER_WAIT: Waiting for "other" message
  6338. + * @DECT_TBC_ESTABLISHED Established
  6339. + * @DECT_TBC_RELEASING First RELEASE message sent
  6340. + * @DECT_TBC_RELEASED: Second RELEASE message sent
  6341. + */
  6342. +enum dect_tbc_state {
  6343. + DECT_TBC_NONE,
  6344. + DECT_TBC_REQ_SENT,
  6345. + DECT_TBC_WAIT_RCVD,
  6346. + DECT_TBC_REQ_RCVD,
  6347. + DECT_TBC_RESPONSE_SENT,
  6348. + DECT_TBC_ATTRIBUTES_SENT,
  6349. + DECT_TBC_OTHER_WAIT,
  6350. + DECT_TBC_ESTABLISHED,
  6351. + DECT_TBC_RELEASING,
  6352. + DECT_TBC_RELEASED,
  6353. +};
  6354. +
  6355. +/**
  6356. + * enum dect_tbc_enc_state - DECT Traffic Bearer encryption state
  6357. + *
  6358. + * @DECT_TBC_ENC_DISABLED: Encryption is disabled
  6359. + * @DECT_TBC_ENC_START_REQ_RCVD: Start request received (FP)
  6360. + * @DECT_TBC_ENC_START_REQ_SENT: Start request sent (PP)
  6361. + * @DECT_TBC_ENC_START_CFM_RCVD: Start confirm received (PP)
  6362. + * @DECT_TBC_ENC_START_CFM_SENT: Start confirm sent (FP)
  6363. + * @DECT_TBC_ENC_STOP_REQ_RCVD: Stop request received (FP)
  6364. + * @DECT_TBC_ENC_STOP_REQ_SENT: Stop request sent (PP)
  6365. + * @DECT_TBC_ENC_STOP_CFM_RCVD: Stop confirm received (PP)
  6366. + * @DECT_TBC_ENC_STOP_CFM_SENT: Stop confirm sent (FP)
  6367. + * @DECT_TBC_ENC_ENABLED: Encryption is enabled
  6368. + */
  6369. +enum dect_tbc_enc_state {
  6370. + DECT_TBC_ENC_DISABLED,
  6371. + DECT_TBC_ENC_START_REQ_RCVD,
  6372. + DECT_TBC_ENC_START_REQ_SENT,
  6373. + DECT_TBC_ENC_START_CFM_RCVD,
  6374. + DECT_TBC_ENC_START_CFM_SENT,
  6375. + DECT_TBC_ENC_STOP_REQ_RCVD,
  6376. + DECT_TBC_ENC_STOP_REQ_SENT,
  6377. + DECT_TBC_ENC_STOP_CFM_RCVD,
  6378. + DECT_TBC_ENC_STOP_CFM_SENT,
  6379. + DECT_TBC_ENC_ENABLED,
  6380. +};
  6381. +
  6382. +/**
  6383. + * enum dect_tbc_event - DECT Traffic Bearer events
  6384. + *
  6385. + * @DECT_TBC_ACK_RECEIVED: Acknowledgement for C_S data received
  6386. + * @DECT_TBC_CIPHER_ENABLED: Ciphering enabled
  6387. + * @DECT_TBC_CIPHER_DISABLED: Ciphering disabled
  6388. + */
  6389. +enum dect_tbc_event {
  6390. + DECT_TBC_ACK_RECEIVED,
  6391. + DECT_TBC_CIPHER_ENABLED,
  6392. + DECT_TBC_CIPHER_DISABLED,
  6393. +};
  6394. +
  6395. +/**
  6396. + * struct dect_tbc - DECT Traffic Bearer Control
  6397. + *
  6398. + * @list: Cell TBC list node
  6399. + * @cell: DECT cell
  6400. + * @id: Traffic Bearer ID
  6401. + * @txb: TX bearer
  6402. + * @rxb: RX bearer
  6403. + * @state: Bearer establishment state
  6404. + * @tx_timer: Transmit activation timer
  6405. + * @wd_timer: Receive watchdog timer
  6406. + * @release_timer: Release timer for unacknowledged release procedure
  6407. + * @release_reason: release reason
  6408. + * @normal_tx_timer: Normal transmit timer for C-channel/I_N normal delay transmission
  6409. + * @normal_rx_timer: Normal receive timer for C-channel/I_N normal delay delivery
  6410. + * @rx_timer: Mimimum delay receive timer
  6411. + * @tx_timer: Minimum delay transmit timer
  6412. + * @ck: Cipher key
  6413. + * @enc_timer: Encryption TX timer
  6414. + * @enc_state: Encryption state
  6415. + * @enc_msg_cnt: Encryption message retransmit counter
  6416. + * @c_rx_skb: C_S segment for delivery to DLC
  6417. + * @c_tx_skb: C_S segment for transmission in next TDMA frame
  6418. + * @c_tx_ok: C_S segment was successfully transmitted
  6419. + * @b_rx_skb: B-field data segment for delivery to DLC
  6420. + * @b_tx_skb: B-field data segment for transmission in next TDMA frame
  6421. + * @bc: Broadcast Control
  6422. + */
  6423. +struct dect_tbc {
  6424. + struct list_head list;
  6425. + struct dect_cell *cell;
  6426. + struct dect_tbc_id id;
  6427. + struct dect_mac_conn_params mcp;
  6428. + bool handover;
  6429. +
  6430. + struct dect_bearer txb;
  6431. + struct dect_bearer rxb;
  6432. +
  6433. + enum dect_tbc_state state;
  6434. + struct dect_timer wait_timer;
  6435. + struct dect_timer wd_timer;
  6436. +
  6437. + struct dect_timer release_timer;
  6438. + enum dect_release_reasons release_reason;
  6439. +
  6440. + /* PP handover trigger */
  6441. + s8 handover_tokens;
  6442. +
  6443. + /* Encryption */
  6444. + u64 ck;
  6445. + struct dect_timer enc_timer;
  6446. + enum dect_tbc_enc_state enc_state:8;
  6447. + u8 enc_msg_cnt;
  6448. +
  6449. + /* C_S channel */
  6450. + struct sk_buff *cs_tx_skb;
  6451. + bool cs_tx_ok;
  6452. +
  6453. + /* I channel */
  6454. + struct sk_buff *b_tx_skb;
  6455. +
  6456. + struct dect_bc bc;
  6457. +};
  6458. +
  6459. +#define DECT_TBC_RFPI_TIMEOUT (5 * DECT_FRAMES_PER_SECOND)
  6460. +
  6461. +#define DECT_TBC_HO_TOKENS_INITIAL 16
  6462. +#define DECT_TBC_HO_TOKENS_OK 1 /* Correct slot adds one token */
  6463. +#define DECT_TBC_HO_TOKENS_ERROR 8 /* Error slot subtracts eight tokens */
  6464. +#define DECT_TBC_HO_TOKENS_MAX 32
  6465. +
  6466. +enum dect_scan_status {
  6467. + DECT_SCAN_FAIL,
  6468. + DECT_SCAN_TIMEOUT,
  6469. + DECT_SCAN_COMPLETE,
  6470. +};
  6471. +
  6472. +/**
  6473. + * struct dect_dmb - Monitor Bearer
  6474. + *
  6475. + * @list: cell dmbs list node
  6476. + * @cell: DECT cell
  6477. + * @rxb1: receive bearer 1
  6478. + * @rxb2: receive bearer 2
  6479. + */
  6480. +struct dect_dmb {
  6481. + struct list_head list;
  6482. + struct dect_cell *cell;
  6483. +
  6484. + struct dect_timer wd_timer;
  6485. + struct dect_bearer rxb1;
  6486. + struct dect_bearer rxb2;
  6487. + struct dect_bc bc;
  6488. +};
  6489. +
  6490. +/**
  6491. + * struct dect_irc - Idle receiver control
  6492. + *
  6493. + * @cell: DECT cell
  6494. + * @trx: DECT transceiver
  6495. + * @ari: ARI filter
  6496. + * @ari_mask: ARI filter mask
  6497. + * @idi: identities information
  6498. + * @si: system information
  6499. + * @notify: notification callback
  6500. + * @rx_scn: Scan carrier number (RX time base)
  6501. + * @tx_scn: Scan carrier number (TX time base)
  6502. + * @rx_frame_timer: rx_scn update timer
  6503. + * @tx_frame_timer: tx_scn update timer
  6504. + */
  6505. +struct dect_irc {
  6506. + struct dect_cell *cell;
  6507. + struct dect_transceiver *trx;
  6508. +
  6509. + struct dect_llme_req lreq;
  6510. +
  6511. + struct dect_ari ari;
  6512. + struct dect_ari ari_mask;
  6513. +
  6514. + u16 timeout;
  6515. + u16 rssi;
  6516. + struct dect_idi idi;
  6517. + struct dect_si si;
  6518. +
  6519. + void (*notify)(struct dect_cell *,
  6520. + struct dect_transceiver *,
  6521. + enum dect_scan_status);
  6522. +
  6523. + u8 rx_scn;
  6524. + u8 tx_scn;
  6525. + struct dect_timer rx_frame_timer;
  6526. + struct dect_timer tx_frame_timer;
  6527. + struct dect_bearer scan_bearer;
  6528. +};
  6529. +
  6530. +#define DECT_IRC_SCN_OFF 3
  6531. +
  6532. +struct dect_scan_result {
  6533. + struct dect_llme_req lreq;
  6534. + struct dect_idi idi;
  6535. + struct dect_si si;
  6536. + u16 rssi;
  6537. +};
  6538. +
  6539. +/**
  6540. + * struct dect_csf_ops - Cell Site Function ops
  6541. + *
  6542. + * @set_mode: set cell to PP/FP mode
  6543. + * @scan: initiate scan for pari/pari_mask
  6544. + * @preload: preload system information
  6545. + * @enable: enable cell
  6546. + * @page_request: deliver paging message
  6547. + * @tbc_initiate: initiate a new connection
  6548. + * @tbc_confirm: confirm an incoming connection
  6549. + * @tbc_release: release a TBC
  6550. + * @tbc_enc_key_request: set encryption key
  6551. + * @tbc_enc_eks_request: enable/disable encryption
  6552. + *
  6553. + * The CSF ops define the interface in the direction CCF -> CSF.
  6554. + */
  6555. +struct dect_cell_handle;
  6556. +struct dect_csf_ops {
  6557. + int (*set_mode)(const struct dect_cell_handle *,
  6558. + enum dect_cluster_modes);
  6559. + int (*scan)(const struct dect_cell_handle *,
  6560. + const struct dect_llme_req *lreq,
  6561. + const struct dect_ari *, const struct dect_ari *);
  6562. + int (*preload)(const struct dect_cell_handle *,
  6563. + const struct dect_ari *, u8,
  6564. + const struct dect_si *);
  6565. + int (*enable)(const struct dect_cell_handle *);
  6566. +
  6567. + void (*page_req)(const struct dect_cell_handle *, struct sk_buff *);
  6568. +
  6569. + int (*tbc_establish_req)(const struct dect_cell_handle *,
  6570. + const struct dect_tbc_id *,
  6571. + const struct dect_mac_conn_params *, bool);
  6572. + int (*tbc_establish_res)(const struct dect_cell_handle *,
  6573. + const struct dect_tbc_id *);
  6574. + void (*tbc_dis_req)(const struct dect_cell_handle *,
  6575. + const struct dect_tbc_id *,
  6576. + enum dect_release_reasons);
  6577. + int (*tbc_enc_key_req)(const struct dect_cell_handle *,
  6578. + const struct dect_tbc_id *, u64 ck);
  6579. + int (*tbc_enc_eks_req)(const struct dect_cell_handle *,
  6580. + const struct dect_tbc_id *,
  6581. + enum dect_cipher_states status);
  6582. + int (*tbc_enc_req)(const struct dect_cell_handle *,
  6583. + const struct dect_tbc_id *, u64 ck);
  6584. + void (*tbc_data_req)(const struct dect_cell_handle *,
  6585. + const struct dect_tbc_id *,
  6586. + enum dect_data_channels chan,
  6587. + struct sk_buff *);
  6588. +
  6589. +};
  6590. +
  6591. +/**
  6592. + * struct dect_cell_handle - DECT cluster view of a cell
  6593. + *
  6594. + * @list: cluster cell list node
  6595. + * @clh: bound cluster handle
  6596. + * @ops: cell site function ops
  6597. + * @rpn: assigned radio part number
  6598. + * @portref: cell control protocol port reference (remote cells)
  6599. + */
  6600. +struct dect_cell_handle {
  6601. + struct list_head list;
  6602. + struct dect_cluster_handle *clh;
  6603. + const struct dect_csf_ops *ops;
  6604. + u8 rpn;
  6605. +
  6606. + u32 portref;
  6607. +};
  6608. +
  6609. +enum dect_cell_states {
  6610. + DECT_CELL_ENABLED = 1 << 0,
  6611. +};
  6612. +
  6613. +/**
  6614. + * struct dect_cell - DECT cell: one radio system
  6615. + *
  6616. + * @list: cell list node
  6617. + * @name: cells' name
  6618. + * @index: unique numeric cell identifier
  6619. + * @flags: operational and status flags
  6620. + * @handle: cell handle
  6621. + * @lock: lock
  6622. + * @mode: operational mode (FP/PP)
  6623. + * @state: bitmask of enum dect_cell_states
  6624. + * @idi: FP System Identity
  6625. + * @fmid: FMID (Fixed MAC IDentity)
  6626. + * @si: FP System Information
  6627. + * @timer_sync_stamp: Time (multiframe number) of last multiframe number sync
  6628. + * @a_rcv_stamp: Time (jiffies) of last received A-Field with correct CRC
  6629. + * @nt_rcv_stamp: Time (jiffies) of last received Nt-Tail containing the PARI
  6630. + * @bcs: Broadcast Controllers
  6631. + * @cbc: Connectionless Bearer Controller
  6632. + * @dbcs: Dummy Bearer Controllers
  6633. + * @tbcs: list of Traffic Bearer Controllers
  6634. + * @tbc_num_est: Number of TBCs in ESTABLISHED state
  6635. + * @tbc_last_chd: Channel description of last TBC leaving ESTABLISHED state
  6636. + * @dmbs: list of Monitor Bearers
  6637. + * @chanlists: list of channel lists for different channel types
  6638. + * @timer_base: RX/TX timer bases
  6639. + * @trg: DECT transceiver group
  6640. + */
  6641. +struct dect_cell {
  6642. + struct list_head list;
  6643. + char name[DECTNAMSIZ];
  6644. + u32 index;
  6645. + u32 flags;
  6646. +
  6647. + struct dect_cell_handle handle;
  6648. +
  6649. + spinlock_t lock;
  6650. + enum dect_cluster_modes mode;
  6651. + u32 state;
  6652. +
  6653. + /* identities */
  6654. + struct dect_idi idi;
  6655. + u16 fmid;
  6656. +
  6657. + /* system information */
  6658. + struct dect_si si;
  6659. + u32 blind_full_slots;
  6660. +
  6661. + /* PP state maintenance */
  6662. + u32 timer_sync_stamp;
  6663. + unsigned long a_rcv_stamp;
  6664. + unsigned long nt_rcv_stamp;
  6665. +
  6666. + /* Broadcast controllers and related data */
  6667. + struct dect_timer page_timer;
  6668. + struct sk_buff_head page_queue;
  6669. + struct sk_buff_head page_fast_queue;
  6670. +
  6671. + struct sk_buff *page_sdu;
  6672. + struct sk_buff_head page_tx_queue;
  6673. +
  6674. + struct list_head bcs;
  6675. + unsigned int si_idx;
  6676. + unsigned long bfs_xmit_stamp;
  6677. +
  6678. + struct dect_cbc cbc;
  6679. + struct list_head dbcs;
  6680. +
  6681. + u32 tbei_rover;
  6682. + struct list_head tbcs;
  6683. + unsigned int tbc_num_est;
  6684. + struct dect_channel_desc tbc_last_chd;
  6685. +
  6686. + struct list_head dmbs;
  6687. +
  6688. + /* channel lists */
  6689. + struct list_head chl_pending;
  6690. + struct list_head chanlists;
  6691. + struct dect_channel_list *chl_next;
  6692. + struct dect_channel_list *chl;
  6693. +
  6694. + /* raw transmission queue */
  6695. + struct sk_buff_head raw_tx_queue;
  6696. +
  6697. + struct dect_timer_base timer_base[DECT_TIMER_BASE_MAX + 1];
  6698. + struct dect_transceiver_group trg;
  6699. + u32 trg_blind_full_slots;
  6700. +};
  6701. +
  6702. +#define DECT_CELL_TIMER_RESYNC_TIMEOUT 8 /* T216: 8 multiframes */
  6703. +#define DECT_CELL_A_RCV_TIMEOUT (5 * HZ) /* T207: 5 seconds */
  6704. +#define DECT_CELL_NT_RCV_TIMEOUT (20 * HZ) /* T208: 20 seconds */
  6705. +
  6706. +#define dect_foreach_transmit_slot(slot, end, cell) \
  6707. + for ((slot) = dect_normal_transmit_base((cell)->mode), \
  6708. + (end) = (slot) + DECT_HALF_FRAME_SIZE; \
  6709. + (slot) < (end); (slot)++)
  6710. +
  6711. +#define dect_foreach_receive_slot(slot, end, cell) \
  6712. + for ((slot) = dect_normal_receive_base((cell)->mode), \
  6713. + (end) = (slot) + DECT_HALF_FRAME_SIZE; \
  6714. + (slot) < (end); (slot)++)
  6715. +
  6716. +extern struct dect_cell *dect_cell_get_by_index(u32 index);
  6717. +
  6718. +extern int dect_cell_attach_transceiver(struct dect_cell *cell,
  6719. + struct dect_transceiver *trx);
  6720. +extern void dect_cell_detach_transceiver(struct dect_cell *cell,
  6721. + struct dect_transceiver *trx);
  6722. +
  6723. +extern void dect_mac_rcv(struct dect_transceiver *trx,
  6724. + struct dect_transceiver_slot *ts,
  6725. + struct sk_buff *skb);
  6726. +extern void dect_mac_report_rssi(struct dect_transceiver *trx,
  6727. + struct dect_transceiver_slot *ts, u8 rssi);
  6728. +extern void dect_mac_rx_tick(struct dect_transceiver_group *grp, u8 slot);
  6729. +extern void dect_mac_tx_tick(struct dect_transceiver_group *grp, u8 slot);
  6730. +
  6731. +extern void dect_mac_irc_rcv(struct dect_transceiver *trx, struct sk_buff *skb);
  6732. +extern void dect_mac_irc_tick(struct dect_transceiver *trx);
  6733. +
  6734. +#endif /* _NET_DECT_MAC_CSF_H */
  6735. diff --git a/include/net/dect/transceiver.h b/include/net/dect/transceiver.h
  6736. new file mode 100644
  6737. index 0000000..2af1f86
  6738. --- /dev/null
  6739. +++ b/include/net/dect/transceiver.h
  6740. @@ -0,0 +1,711 @@
  6741. +/*
  6742. + * DECT Transceiver Layer
  6743. + *
  6744. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  6745. + */
  6746. +
  6747. +#ifndef _NET_DECT_TRANSCEIVER_H
  6748. +#define _NET_DECT_TRANSCEIVER_H
  6749. +
  6750. +#include <linux/interrupt.h>
  6751. +#include <linux/list.h>
  6752. +#include <linux/skbuff.h>
  6753. +#include <linux/dect.h>
  6754. +#include <linux/dect_netlink.h>
  6755. +
  6756. +#define DECT_RSSI_RANGE 255
  6757. +#define DECT_RSSI_DBM_LOW -93
  6758. +#define DECT_RSSI_DBM_RANGE 60
  6759. +
  6760. +static inline u8 dect_dbm_to_rssi_rel(s8 dbm)
  6761. +{
  6762. + return dbm * DECT_RSSI_RANGE / DECT_RSSI_DBM_RANGE;
  6763. +}
  6764. +
  6765. +static inline u8 dect_dbm_to_rssi(s8 dbm)
  6766. +{
  6767. + return dect_dbm_to_rssi_rel(dbm - DECT_RSSI_DBM_LOW);
  6768. +}
  6769. +
  6770. +#define DECT_RSSI_AVG_SCALE 3
  6771. +
  6772. +static inline u16 dect_average_rssi(u16 cur, u16 sample)
  6773. +{
  6774. + if (cur == 0)
  6775. + cur = sample << DECT_RSSI_AVG_SCALE;
  6776. + else {
  6777. + cur -= cur >> DECT_RSSI_AVG_SCALE;
  6778. + cur += sample;
  6779. + }
  6780. + return cur;
  6781. +}
  6782. +
  6783. +#define DECT_CARRIER_NUM 64
  6784. +
  6785. +static inline u8 dect_next_carrier(u64 rfcars, u8 carrier)
  6786. +{
  6787. + u64 tmp;
  6788. +
  6789. + if (WARN_ON(rfcars == 0))
  6790. + return 0;
  6791. + tmp = rfcars & ~((1ULL << (carrier + 1)) - 1);
  6792. + if (tmp == 0)
  6793. + tmp = rfcars;
  6794. + return ffs(tmp) - 1;
  6795. +}
  6796. +
  6797. +static inline u8 dect_prev_carrier(u64 rfcars, u8 carrier)
  6798. +{
  6799. + u64 tmp;
  6800. +
  6801. + if (WARN_ON(rfcars == 0))
  6802. + return 0;
  6803. + tmp = rfcars & ((1ULL << carrier) - 1);
  6804. + if (tmp == 0)
  6805. + tmp = rfcars;
  6806. + return fls(tmp) - 1;
  6807. +}
  6808. +
  6809. +static inline u8 dect_carrier_sub(u64 rfcars, u8 carrier, u8 n)
  6810. +{
  6811. + while (n != 0) {
  6812. + carrier = dect_prev_carrier(rfcars, carrier);
  6813. + n--;
  6814. + }
  6815. + return carrier;
  6816. +}
  6817. +
  6818. +static inline u8 dect_carrier_distance(u64 rfcars, u8 from, u8 to)
  6819. +{
  6820. + if (from >= to) {
  6821. + /* clear bits between to and from */
  6822. + rfcars &= ~(((1ULL << (from - to)) - 1) << to);
  6823. + } else {
  6824. + /* clear bits not between from and to */
  6825. + rfcars &= ((1ULL << (to - from)) - 1) << from;
  6826. + }
  6827. + return hweight64(rfcars);
  6828. +}
  6829. +
  6830. +#define DECT_PHASE_OFFSET_EWMA_LOG (DECT_PHASE_OFFSET_SCALE / 4)
  6831. +
  6832. +static inline s32 dect_average_phase_offset(s32 cur, s32 phaseoff)
  6833. +{
  6834. + cur -= cur / DECT_PHASE_OFFSET_EWMA_LOG;
  6835. + cur += phaseoff / DECT_PHASE_OFFSET_EWMA_LOG;
  6836. + return cur;
  6837. +}
  6838. +
  6839. +#define DECT_BAND_NUM 32
  6840. +#define DECT_DEFAULT_BAND 0
  6841. +
  6842. +#define DECT_FREQUENCY_F0 1897344 /* kHz */
  6843. +#define DECT_CARRIER_WIDTH 1728 /* kHz */
  6844. +
  6845. +/**
  6846. + * struct dect_band - DECT RF-band
  6847. + *
  6848. + * @band: RF-band number
  6849. + * @carriers: number of defined carriers
  6850. + * @frequency: frequency of each carrier in kHz
  6851. + */
  6852. +struct dect_band {
  6853. + u8 band;
  6854. + u8 carriers;
  6855. + u32 frequency[];
  6856. +};
  6857. +
  6858. +#define DECT_FRAME_SIZE 24
  6859. +#define DECT_HALF_FRAME_SIZE (DECT_FRAME_SIZE / 2)
  6860. +#define DECT_FRAMES_PER_SECOND 100
  6861. +
  6862. +#define DECT_SCAN_SLOT 0
  6863. +#define DECT_SLOT_MASK 0x00ffffff
  6864. +
  6865. +static inline u8 dect_next_slotnum(u8 slot)
  6866. +{
  6867. + if (++slot == DECT_FRAME_SIZE)
  6868. + slot = 0;
  6869. + return slot;
  6870. +}
  6871. +
  6872. +static inline u8 dect_prev_slotnum(u8 slot)
  6873. +{
  6874. + if (slot == 0)
  6875. + slot = DECT_FRAME_SIZE;
  6876. + return slot - 1;
  6877. +}
  6878. +
  6879. +static inline u8 dect_slot_add(u8 s1, u8 s2)
  6880. +{
  6881. + return (s1 + s2) % DECT_FRAME_SIZE;
  6882. +}
  6883. +
  6884. +static inline u8 dect_slot_sub(u8 s1, u8 s2)
  6885. +{
  6886. + return s1 >= s2 ? s1 - s2 : DECT_FRAME_SIZE + s1 - s2;
  6887. +}
  6888. +
  6889. +static inline u8 dect_slot_distance(u8 s1, u8 s2)
  6890. +{
  6891. + return s2 >= s1 ? s2 - s1 : DECT_FRAME_SIZE + s2 - s1;
  6892. +}
  6893. +
  6894. +#define dect_foreach_slot(slot) \
  6895. + for ((slot) = 0; (slot) < DECT_FRAME_SIZE; (slot)++)
  6896. +
  6897. +static inline u8 dect_normal_transmit_base(enum dect_cluster_modes mode)
  6898. +{
  6899. + return mode == DECT_MODE_FP ? 0 : DECT_HALF_FRAME_SIZE;
  6900. +}
  6901. +
  6902. +static inline u8 dect_normal_receive_base(enum dect_cluster_modes mode)
  6903. +{
  6904. + return mode == DECT_MODE_FP ? DECT_HALF_FRAME_SIZE : 0;
  6905. +}
  6906. +
  6907. +static inline u8 dect_normal_receive_end(enum dect_cluster_modes mode)
  6908. +{
  6909. + return mode == DECT_MODE_FP ? DECT_FRAME_SIZE - 1 :
  6910. + DECT_HALF_FRAME_SIZE - 1;
  6911. +}
  6912. +
  6913. +static inline u8 dect_tdd_slot(u8 slot)
  6914. +{
  6915. + return slot < DECT_HALF_FRAME_SIZE ? slot + DECT_HALF_FRAME_SIZE :
  6916. + slot - DECT_HALF_FRAME_SIZE;
  6917. +}
  6918. +
  6919. +enum dect_packet_sizes {
  6920. + DECT_P00_SIZE = 12,
  6921. + DECT_P08_SIZE = 23,
  6922. + DECT_P32_SIZE = 53,
  6923. + DECT_P640j_SIZE = 89,
  6924. + DECT_P672j_SIZE = 93,
  6925. + DECT_P80_SIZE = 113,
  6926. +};
  6927. +
  6928. +#define DECT_PREAMBLE_SIZE 4
  6929. +
  6930. +/**
  6931. + * enum dect_checksum - DECT hardware checksum results
  6932. + *
  6933. + * @DECT_CHECKSUM_A_CRC_OK: A-field R-CRC OK
  6934. + * @DECT_CHECKSUM_X_CRC_OK: Unprotected B-field X-CRC OK
  6935. + * @DECT_CHECKSUM_Z_CRC_OK: Z-field OK
  6936. + */
  6937. +enum dect_checksum {
  6938. + DECT_CHECKSUM_A_CRC_OK = 0x1,
  6939. + DECT_CHECKSUM_X_CRC_OK = 0x2,
  6940. + DECT_CHECKSUM_Z_CRC_OK = 0x4,
  6941. +};
  6942. +
  6943. +/**
  6944. + * enum dect_b_formats - DECT B-Field formats
  6945. + *
  6946. + * @DECT_B_NONE: No B-field
  6947. + * @DECT_B_UNPROTECTED: Unprotected B-field format
  6948. + * @DECT_B_PROTECTED: Protected B-field format
  6949. + *
  6950. + * The B-Field format can be used by a transceiver for offloading X-CRC
  6951. + * calculation.
  6952. + */
  6953. +enum dect_b_formats {
  6954. + DECT_B_NONE,
  6955. + DECT_B_UNPROTECTED,
  6956. + DECT_B_PROTECTED,
  6957. + __DECT_B_MAX
  6958. +};
  6959. +#define DECT_B_MAX (__DECT_B_MAX - 1)
  6960. +
  6961. +/**
  6962. + * struct dect_channel_desc - DECT physical channel description
  6963. + *
  6964. + * @pkt: Packet type in use
  6965. + * @b_fmt: B-Field format for checksum offloading
  6966. + * @slot: Slot number
  6967. + * @carrier: RF-carrier number
  6968. + */
  6969. +struct dect_channel_desc {
  6970. + enum dect_packet_types pkt:8;
  6971. + enum dect_b_formats b_fmt:8;
  6972. + u8 slot;
  6973. + u8 carrier;
  6974. +};
  6975. +
  6976. +enum dect_channel_priv_flags {
  6977. + DECT_SLOT_RAW_TX = 0x1,
  6978. +};
  6979. +
  6980. +/**
  6981. + * struct dect_transceiver_slot - Transceiver TDMA slot
  6982. + *
  6983. + * @flags: slot flags
  6984. + * @priv_flags: internally used flags
  6985. + * @state: current state
  6986. + * @desc: channel description
  6987. + * @bearer: associated bearer
  6988. + * @ck: cipher key
  6989. + * @phaseoff: measured phase offset
  6990. + * @rssi: averaged RSSI
  6991. + * @rx_bytes: RX byte count
  6992. + * @rx_packets: RX packet count
  6993. + * @rx_a_crc_errors: RX A-field CRC errors
  6994. + * @tx_bytes: TX byte count
  6995. + * @tx_packets: TX packet count
  6996. + */
  6997. +struct dect_transceiver_slot {
  6998. + u8 flags;
  6999. + u8 priv_flags;
  7000. + u8 blinded;
  7001. + enum dect_slot_states state:8;
  7002. + struct dect_channel_desc chd;
  7003. + struct dect_bearer *bearer;
  7004. + u64 ck;
  7005. +
  7006. + s32 phaseoff;
  7007. + u16 rssi;
  7008. + u32 rx_bytes;
  7009. + u32 rx_packets;
  7010. + u32 rx_a_crc_errors;
  7011. + u32 rx_x_crc_errors;
  7012. + u32 rx_z_crc_errors;
  7013. + u32 tx_bytes;
  7014. + u32 tx_packets;
  7015. +};
  7016. +
  7017. +/**
  7018. + * struct dect_transceiver_event - one atomic unit of work for the MAC layer
  7019. + *
  7020. + * @trx: transceiver
  7021. + * @busy: synchronizer
  7022. + * @list: transceiver group events list node
  7023. + * @rx_queue: received packets
  7024. + * @rssi: RSSI measurement in scanning slots
  7025. + * @rssi_mask: RSSI measurement positions
  7026. + * @slotpos: transceiver slot position in TDMA frame
  7027. + *
  7028. + * A transceiver operates asynchronously to the MAC layer, but the MAC layer's
  7029. + * timing needs to be strictly synchronized to the receiver.
  7030. + *
  7031. + * This structure contains the packets from multiple consequitive slots received
  7032. + * by the receiver in one unit (up to ops->eventrate frames). Slotpos specifies
  7033. + * the transceivers current position in the TDMA frame (== the minimum current
  7034. + * time) and is used for timing purposes and slot maintenance operations of the
  7035. + * upcoming slots. A transceiver uses a fixed amount of these structure and
  7036. + * synchronizes with BH processing through the busy marker. When BH processing
  7037. + * is too slow, frames are dropped.
  7038. + */
  7039. +struct dect_transceiver_event {
  7040. + struct dect_transceiver *trx;
  7041. + atomic_t busy;
  7042. + struct list_head list;
  7043. + struct sk_buff_head rx_queue;
  7044. + u8 rssi[DECT_HALF_FRAME_SIZE / 2];
  7045. + u8 rssi_mask;
  7046. + u8 slotpos;
  7047. +};
  7048. +
  7049. +/**
  7050. + * struct dect_skb_trx_cb - DECT Transceiver skb control block
  7051. + *
  7052. + * @trx: transceiver
  7053. + * @mfn: multiframe number
  7054. + * @frame: frame number
  7055. + * @slot: slot number
  7056. + * @lbn: logical bearer number
  7057. + * @csum: checksum results
  7058. + * @rssi: RSSI measurement
  7059. + */
  7060. +struct dect_skb_trx_cb {
  7061. + struct dect_transceiver *trx;
  7062. + u32 mfn;
  7063. + u8 frame;
  7064. + u8 slot;
  7065. + u8 lbn;
  7066. + u8 csum;
  7067. + u8 rssi;
  7068. +};
  7069. +
  7070. +static inline struct dect_skb_trx_cb *DECT_TRX_CB(const struct sk_buff *skb)
  7071. +{
  7072. + BUILD_BUG_ON(sizeof(struct dect_skb_trx_cb) > sizeof(skb->cb));
  7073. + return (struct dect_skb_trx_cb *)skb->cb;
  7074. +}
  7075. +
  7076. +/**
  7077. + * struct dect_transceiver_ops - DECT transceiver operations
  7078. + *
  7079. + * @disable: shut the transceiver down
  7080. + * @enable: bring the transceiver to operational state
  7081. + * @confirm: confirm a received signal in slave mode
  7082. + * @unlock: release a confirmed signal again
  7083. + * @lock: lock to a signal
  7084. + * @set_mode: set the mode (RX/TX/SCANNING) for a slot
  7085. + * @set_carrier: set the RF-carrier for a slot
  7086. + * @set_band: set the RF-band
  7087. + * @destructor: destructor
  7088. + * @name transceiver driver name
  7089. + * @features: transceiver features
  7090. + * @eventrate: rate at which slot events are generated, must be integral
  7091. + * divisor of the number of slots per TDMA half frame
  7092. + * @latency: latency in slots until updates for a slot take effect
  7093. + *
  7094. + * A transceiver provides frame reception and transmission, signal strength
  7095. + * measurement as well as a reference clock for the MAC layer. It can exist
  7096. + * in two basic states:
  7097. + *
  7098. + * - master: doesn't need initial synchronization to a radio signal
  7099. + * - slave: needs to synchronize timing with a signal
  7100. + *
  7101. + * Only the first transceiver of a FP is a master, PPs are always slaves to
  7102. + * a FPs timing. Secondary and further transceivers of a FP also start as
  7103. + * slaves until they have synchronized to one of the already running
  7104. + * transceivers.
  7105. + *
  7106. + * Locking to a new signal works in multiple phases:
  7107. + *
  7108. + * 1) The ->enable() callback is invoked. The driver is expected to initiate a
  7109. + * scan for a signal, during which it will pass on any received frame to the
  7110. + * transceiver layer. As no framing has been established, all packets should
  7111. + * indicate a slot number of zero.
  7112. + *
  7113. + * 2) While scanning for a signal, the ->set_carrier() callback may be invoked
  7114. + * with a slot number of zero. The driver is expected to adjust the carrier
  7115. + * on which it is scanning for a signal.
  7116. + *
  7117. + * 3) When the MAC layer determines interest in a received signal, the ->confirm()
  7118. + * callback is invoked. The driver is expected to continue to pass frames from
  7119. + * this signal to the MAC layer to establish framing.
  7120. + *
  7121. + * 3a) When the MAC layer is only collecting information for a scan, it may call
  7122. + * the ->unlock callback to release a previously confirmed signal.
  7123. + *
  7124. + * 4) Once the MAC layer has determined framing relative to the slot timing, the
  7125. + * ->lock() callback is invoked. At this point, only a single physical channel
  7126. + * is received. The driver should synchronize the hardware to the framing to
  7127. + * make it interrupt at the appropriate times.
  7128. + *
  7129. + */
  7130. +struct dect_transceiver;
  7131. +struct dect_transceiver_ops {
  7132. + void (*disable)(const struct dect_transceiver *trx);
  7133. + void (*enable)(const struct dect_transceiver *trx);
  7134. +
  7135. + void (*confirm)(const struct dect_transceiver *trx);
  7136. + void (*unlock)(const struct dect_transceiver *trx);
  7137. + void (*lock)(const struct dect_transceiver *trx, u8 slot);
  7138. +
  7139. + void (*set_mode)(const struct dect_transceiver *trx,
  7140. + const struct dect_channel_desc *chd,
  7141. + enum dect_slot_states mode);
  7142. + void (*set_carrier)(const struct dect_transceiver *trx,
  7143. + u8 slot, u8 carrier);
  7144. + void (*tx)(const struct dect_transceiver *trx,
  7145. + struct sk_buff *skb);
  7146. +
  7147. + u64 (*set_band)(const struct dect_transceiver *trx,
  7148. + const struct dect_band *band);
  7149. + void (*destructor)(struct dect_transceiver *trx);
  7150. + const char *name;
  7151. +
  7152. + u32 features;
  7153. + u8 eventrate;
  7154. + u8 latency;
  7155. +};
  7156. +
  7157. +/**
  7158. + * enum dect_transceiver_modes - Transceiver synchronization modes
  7159. + *
  7160. + * @DECT_TRANSCEIVER_MASTER: Transceiver determines reference time (FP)
  7161. + * @DECT_TRANSCEIVER_SLAVE: Transceiver is slave to foreign reference timing
  7162. + */
  7163. +enum dect_transceiver_modes {
  7164. + DECT_TRANSCEIVER_MASTER,
  7165. + DECT_TRANSCEIVER_SLAVE,
  7166. +};
  7167. +
  7168. +/**
  7169. + * enum dect_transceiver_states - transceiver synchronization states
  7170. + *
  7171. + * @DECT_TRANSCEIVER_STOPPED: transceiver is inactive
  7172. + * @DECT_TRANSCEIVER_UNLOCKED: transceiver is not synchronized to any RFP
  7173. + * @DECT_TRANSCEIVER_LOCK_PENDING: transceiver is receiving RFP transmissions,
  7174. + * but has not obtained frame synchonization
  7175. + * @DECT_TRANSCEIVER_LOCKED: the transceiver has achieved frame and
  7176. + * multiframe lock to an RFP
  7177. + *
  7178. + * These correspond to the ETS 300 175-3 Annex D PT MAC layer states, but are
  7179. + * per transceiver as we also need to synchronize secondary transceivers.
  7180. + */
  7181. +enum dect_transceiver_states {
  7182. + DECT_TRANSCEIVER_STOPPED,
  7183. + DECT_TRANSCEIVER_UNLOCKED,
  7184. + DECT_TRANSCEIVER_LOCK_PENDING,
  7185. + DECT_TRANSCEIVER_LOCKED,
  7186. +};
  7187. +
  7188. +/**
  7189. + * struct dect_transceiver_stats - transceiver statistics
  7190. + *
  7191. + * @event_busy: events lost due to MAC layer busy
  7192. + * @event_late: events lost due to transceiver late
  7193. + */
  7194. +struct dect_transceiver_stats {
  7195. + u32 event_busy;
  7196. + u32 event_late;
  7197. +};
  7198. +
  7199. +/**
  7200. + * struct dect_transceiver - DECT transceiver
  7201. + *
  7202. + * @list: transceiver list node
  7203. + * @ops: transceiver ops
  7204. + * @name: transceiver identity
  7205. + * @stats: transceiver statistics
  7206. + * @mode: synchronization mode
  7207. + * @state: synchronization state
  7208. + * @band: current RF-band
  7209. + * @carriers: bitmask of supported carriers in the current band
  7210. + * @slots: transceiver slot state
  7211. + * @index: cell transceiver index
  7212. + * @segno: transceiver receive sequence number
  7213. + * @cell: cell the transceiver is assigned to
  7214. + * @irc: idle receiver control
  7215. + * @event: dynamic amount of transceiver event structures
  7216. + *
  7217. + * Following the event structures is the private driver data.
  7218. + */
  7219. +struct dect_transceiver {
  7220. + struct list_head list;
  7221. + const struct dect_transceiver_ops *ops;
  7222. + char name[DECTNAMSIZ];
  7223. +
  7224. + struct dect_transceiver_stats stats;
  7225. + enum dect_transceiver_modes mode;
  7226. + enum dect_transceiver_states state;
  7227. +
  7228. + const struct dect_band *band;
  7229. + u64 carriers;
  7230. +
  7231. + struct dect_transceiver_slot slots[DECT_FRAME_SIZE];
  7232. + u32 blind_full_slots;
  7233. +
  7234. + u8 index;
  7235. + u32 seqno;
  7236. + struct dect_cell *cell;
  7237. + struct dect_irc *irc;
  7238. + struct dect_transceiver_event event[];
  7239. +};
  7240. +
  7241. +static inline void *dect_transceiver_priv(const struct dect_transceiver *trx)
  7242. +{
  7243. + return (void *)&trx->event[DECT_HALF_FRAME_SIZE / trx->ops->eventrate];
  7244. +}
  7245. +
  7246. +extern struct dect_transceiver *dect_transceiver_alloc(const struct dect_transceiver_ops *ops,
  7247. + unsigned int priv);
  7248. +extern void dect_transceiver_free(struct dect_transceiver *trx);
  7249. +extern int dect_register_transceiver(struct dect_transceiver *trx);
  7250. +extern void dect_unregister_transceiver(struct dect_transceiver *trx);
  7251. +
  7252. +extern void dect_transceiver_enable(struct dect_transceiver *trx);
  7253. +extern void dect_transceiver_disable(struct dect_transceiver *trx);
  7254. +
  7255. +extern void dect_transceiver_confirm(struct dect_transceiver *trx);
  7256. +extern void dect_transceiver_unlock(struct dect_transceiver *trx);
  7257. +extern void dect_transceiver_lock(struct dect_transceiver *trx, u8 slot);
  7258. +
  7259. +extern int dect_transceiver_set_band(struct dect_transceiver *trx, u8 bandnum);
  7260. +
  7261. +static inline void dect_set_channel_mode(struct dect_transceiver *trx,
  7262. + const struct dect_channel_desc *chd,
  7263. + enum dect_slot_states mode)
  7264. +{
  7265. + trx->ops->set_mode(trx, chd, mode);
  7266. + trx->slots[chd->slot].state = mode;
  7267. + trx->slots[chd->slot].chd.pkt = chd->pkt;
  7268. + trx->slots[chd->slot].chd.b_fmt = chd->b_fmt;
  7269. +}
  7270. +
  7271. +static inline void dect_set_carrier(struct dect_transceiver *trx,
  7272. + u8 slot, u8 carrier)
  7273. +{
  7274. + trx->slots[slot].chd.carrier = carrier;
  7275. + trx->slots[slot].rssi = 0;
  7276. + trx->slots[slot].phaseoff = 0;
  7277. + trx->ops->set_carrier(trx, slot, carrier);
  7278. +}
  7279. +
  7280. +static inline void dect_set_flags(struct dect_transceiver *trx, u8 slot, u32 flags)
  7281. +{
  7282. + trx->slots[slot].flags |= flags;
  7283. + trx->ops->set_mode(trx, &trx->slots[slot].chd, trx->slots[slot].state);
  7284. +}
  7285. +
  7286. +static inline void dect_clear_flags(struct dect_transceiver *trx, u8 slot, u32 flags)
  7287. +{
  7288. + trx->slots[slot].flags &= ~flags;
  7289. + trx->ops->set_mode(trx, &trx->slots[slot].chd, trx->slots[slot].state);
  7290. +}
  7291. +
  7292. +static inline void dect_enable_cipher(struct dect_transceiver *trx,
  7293. + const struct dect_channel_desc *chd,
  7294. + u64 ck)
  7295. +{
  7296. + trx->slots[chd->slot].ck = ck;
  7297. + dect_set_flags(trx, chd->slot, DECT_SLOT_CIPHER);
  7298. +}
  7299. +
  7300. +static inline void dect_disable_cipher(struct dect_transceiver *trx,
  7301. + const struct dect_channel_desc *chd)
  7302. +{
  7303. + dect_clear_flags(trx, chd->slot, DECT_SLOT_CIPHER);
  7304. + trx->slots[chd->slot].ck = 0;
  7305. +}
  7306. +
  7307. +static inline void dect_transceiver_tx(struct dect_transceiver *trx,
  7308. + struct sk_buff *skb)
  7309. +{
  7310. + u8 slot = DECT_TRX_CB(skb)->slot;
  7311. +
  7312. + trx->slots[slot].tx_bytes += skb->len;
  7313. + trx->slots[slot].tx_packets++;
  7314. + trx->ops->tx(trx, skb);
  7315. +}
  7316. +
  7317. +extern struct sk_buff *dect_transceiver_alloc_skb(struct dect_transceiver *trx, u8 slot);
  7318. +
  7319. +static inline struct dect_transceiver_event *
  7320. +dect_transceiver_event(struct dect_transceiver *trx, u8 n, u8 slotpos)
  7321. +{
  7322. + struct dect_transceiver_event *event;
  7323. +
  7324. + event = &trx->event[n];
  7325. + if (unlikely(!atomic_add_unless(&event->busy, 1, 1))) {
  7326. + trx->stats.event_busy++;
  7327. + return NULL;
  7328. + }
  7329. + event->slotpos = slotpos;
  7330. + return event;
  7331. +}
  7332. +
  7333. +static inline void dect_transceiver_record_rssi(struct dect_transceiver_event *event,
  7334. + u8 slot, u8 rssi)
  7335. +{
  7336. + u8 idx;
  7337. +
  7338. + idx = slot % event->trx->ops->eventrate;
  7339. + event->rssi[idx] = rssi;
  7340. + event->rssi_mask |= 1 << idx;
  7341. +}
  7342. +
  7343. +static inline void dect_release_transceiver_event(struct dect_transceiver_event *event)
  7344. +{
  7345. + event->rssi_mask = 0;
  7346. + smp_mb();
  7347. + atomic_dec(&event->busy);
  7348. +}
  7349. +
  7350. +enum dect_transceiver_events {
  7351. + DECT_TRANSCEIVER_REGISTER,
  7352. + DECT_TRANSCEIVER_UNREGISTER,
  7353. +};
  7354. +
  7355. +#define DECT_TRX_GROUP_MAX 16
  7356. +
  7357. +/**
  7358. + * struct dect_transceiver_group
  7359. + *
  7360. + * @trx: Transceiver array
  7361. + * @trxmask: Mask of present transceivers
  7362. + * @latency: Maximum latency of all transceivers
  7363. + * @features: Combined features of all transceivers
  7364. + * @blind_full_slots: combined blind full slots state of all transceivers
  7365. + * @tasklet: Event processing tasklet
  7366. + * @lock: Event list lock
  7367. + * @events: List of queued events
  7368. + * @seqno: Transceiver event loss detection
  7369. + * @slot_low: First unhandled slot
  7370. + * @slot_high: First slot after slot window
  7371. + * @slots: merged events for window slot_low - slot_high
  7372. + */
  7373. +struct dect_transceiver_group {
  7374. + struct dect_transceiver *trx[DECT_TRX_GROUP_MAX];
  7375. + u16 trxmask;
  7376. + u8 latency;
  7377. + u32 features;
  7378. + u32 blind_full_slots;
  7379. +
  7380. + struct tasklet_struct tasklet;
  7381. + spinlock_t lock;
  7382. + struct list_head events;
  7383. +
  7384. + u32 seqno;
  7385. + u8 slot_low;
  7386. + u8 slot_high;
  7387. + struct {
  7388. + struct sk_buff_head queue;
  7389. + u16 mask;
  7390. + u8 rssi[DECT_TRX_GROUP_MAX];
  7391. + } slots[DECT_HALF_FRAME_SIZE];
  7392. +};
  7393. +
  7394. +extern void dect_transceiver_group_init(struct dect_transceiver_group *trg);
  7395. +extern int dect_transceiver_group_add(struct dect_transceiver_group *trg,
  7396. + struct dect_transceiver *trx);
  7397. +extern void dect_transceiver_group_remove(struct dect_transceiver_group *trg,
  7398. + struct dect_transceiver *trx);
  7399. +
  7400. +extern bool dect_transceiver_channel_available(const struct dect_transceiver *trx,
  7401. + const struct dect_channel_desc *chd);
  7402. +extern bool dect_transceiver_reserve(struct dect_transceiver_group *trg,
  7403. + struct dect_transceiver *trx,
  7404. + const struct dect_channel_desc *chd);
  7405. +extern bool dect_transceiver_release(struct dect_transceiver_group *trg,
  7406. + struct dect_transceiver *trx,
  7407. + const struct dect_channel_desc *chd);
  7408. +
  7409. +extern void dect_transceiver_queue_event(struct dect_transceiver *trx,
  7410. + struct dect_transceiver_event *ev);
  7411. +
  7412. +#define dect_first_transceiver(trg) \
  7413. +({ \
  7414. + struct dect_transceiver_group *_trg = (void *)(trg); \
  7415. + u32 mask = _trg->trxmask; \
  7416. + mask ? (_trg)->trx[ffs(mask) - 1] : NULL; })
  7417. +
  7418. +#define dect_next_transceiver(trx, trg) \
  7419. +({ \
  7420. + struct dect_transceiver_group *_trg = (void *)(trg); \
  7421. + u32 mask = _trg->trxmask; \
  7422. + mask &= ~((1 << ((trx)->index + 1)) - 1); \
  7423. + mask ? (_trg)->trx[ffs(mask) - 1] : NULL; })
  7424. +
  7425. +#define dect_foreach_transceiver(trx, trg) \
  7426. + for ((trx) = dect_first_transceiver(trg); \
  7427. + (trx) != NULL; \
  7428. + (trx) = dect_next_transceiver(trx, trg))
  7429. +
  7430. +#define dect_last_transceiver(trg) \
  7431. +({ \
  7432. + struct dect_transceiver_group *_trg = (void *)(trg); \
  7433. + u32 mask = _trg->trxmask; \
  7434. + mask ? (_trg)->trx[fls(mask) - 1] : NULL; })
  7435. +
  7436. +#define dect_prev_transceiver(trx, trg) \
  7437. +({ \
  7438. + struct dect_transceiver_group *_trg = (void *)(trg); \
  7439. + u32 mask = _trg->trxmask; \
  7440. + mask &= (1 << (trx)->index) - 1; \
  7441. + mask ? (_trg)->trx[fls(mask) - 1] : NULL; })
  7442. +
  7443. +#define dect_foreach_transceiver_reverse(trx, trg) \
  7444. + for ((trx) = dect_last_transceiver(trg); \
  7445. + (trx) != NULL; \
  7446. + (trx) = dect_prev_transceiver(trx, trg))
  7447. +
  7448. +extern int dect_transceiver_module_init(void);
  7449. +extern void dect_transceiver_module_exit(void);
  7450. +
  7451. +#endif /* _NET_DECT_TRANSCEIVER_H */
  7452. diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild
  7453. index 855908e..517038d 100644
  7454. --- a/include/uapi/linux/Kbuild
  7455. +++ b/include/uapi/linux/Kbuild
  7456. @@ -100,6 +100,8 @@ header-y += cyclades.h
  7457. header-y += cycx_cfm.h
  7458. header-y += dcbnl.h
  7459. header-y += dccp.h
  7460. +header-y += dect.h
  7461. +header-y += dect_netlink.h
  7462. header-y += devlink.h
  7463. header-y += dlmconstants.h
  7464. header-y += dlm_device.h
  7465. diff --git a/include/uapi/linux/dect.h b/include/uapi/linux/dect.h
  7466. new file mode 100644
  7467. index 0000000..e458a9c
  7468. --- /dev/null
  7469. +++ b/include/uapi/linux/dect.h
  7470. @@ -0,0 +1,206 @@
  7471. +#ifndef _LINUX_DECT_H
  7472. +#define _LINUX_DECT_H
  7473. +
  7474. +#define DECTNAMSIZ 16
  7475. +
  7476. +#include <linux/types.h>
  7477. +#include <linux/socket.h>
  7478. +
  7479. +/* these have to be macros in order to be usable for module aliases */
  7480. +#define DECT_RAW 0 /* raw frames */
  7481. +#define DECT_B_SAP 1 /* DLC Broadcast Service */
  7482. +#define DECT_S_SAP 2 /* DLC Data Link Service */
  7483. +#define DECT_LU1_SAP 3 /* LU1 sockets */
  7484. +#define DECT_PROTO_NUM 4
  7485. +
  7486. +/**
  7487. + * struct sockaddr_dect
  7488. + *
  7489. + * @dect_family: address family (AF_DECT)
  7490. + * @dect_index: cluster index
  7491. + */
  7492. +struct sockaddr_dect {
  7493. + sa_family_t dect_family;
  7494. + int dect_index;
  7495. +};
  7496. +
  7497. +/* raw sockets */
  7498. +
  7499. +#define DECT_RAW_AUXDATA 0
  7500. +
  7501. +/**
  7502. + * struct dect_raw_auxdata - raw socket auxiliary frame data
  7503. + *
  7504. + * @mfn: multi-frame number
  7505. + * @frame: frame number
  7506. + * @slot: slot numer
  7507. + * @rssi: receive signal strength indicator
  7508. + */
  7509. +struct dect_raw_auxdata {
  7510. + __u32 mfn;
  7511. + __u8 frame;
  7512. + __u8 slot;
  7513. + __u8 rssi;
  7514. +};
  7515. +
  7516. +#define DECT_BSAP_AUXDATA 0
  7517. +
  7518. +/**
  7519. + * struct dect_bsap_auxdata
  7520. + *
  7521. + * @long_page: message contains a long page
  7522. + */
  7523. +struct dect_bsap_auxdata {
  7524. + __u8 long_page;
  7525. +};
  7526. +
  7527. +/**
  7528. + * enum dect_sapis - S SAP Identifier
  7529. + *
  7530. + * @DECT_SAPI_CO_SIGNALLING: connection oriented signalling
  7531. + * @DECT_SAPI_CL_SIGNALLING: connectionless signalling
  7532. + * @DECT_SAPI_ANY: wildcard
  7533. + */
  7534. +enum dect_sapis {
  7535. + DECT_SAPI_CO_SIGNALLING = 0,
  7536. + DECT_SAPI_CL_SIGNALLING = 3,
  7537. + DECT_SAPI_ANY = 7,
  7538. +};
  7539. +
  7540. +/**
  7541. + * enum dect_llns - Logical Link Numbers
  7542. + *
  7543. + * @DECT_LLN_CLASS_U: Class U operation
  7544. + * @DECT_LLN_CLASS_A: Class A operation
  7545. + * @DECT_LLN_ASSIGNABLE*: Assignable LLN (class B operation)
  7546. + * @DECT_LLN_UNASSIGNED: LLN unassigned (class B operation
  7547. + * @DECT_LLN_ANY: wildcard
  7548. + */
  7549. +enum dect_llns {
  7550. + DECT_LLN_CLASS_U = 0,
  7551. + DECT_LLN_CLASS_A = 1,
  7552. + DECT_LLN_ASSIGNABLE_MIN = 2,
  7553. + DECT_LLN_ASSIGNABLE_MAX = 6,
  7554. + DECT_LLN_UNASSIGNED = 7,
  7555. + DECT_LLN_ANY = 15,
  7556. +};
  7557. +
  7558. +/**
  7559. + * struct sockaddr_dect_ssap
  7560. + *
  7561. + * @dect_family: family (AF_DECT)
  7562. + * @dect_lln: logical link number
  7563. + * @dect_sapi: service access point identifier
  7564. + * @dect_class: class A/B
  7565. + * @dect_index: cluster index
  7566. + * @dect_ari: ARI
  7567. + * @dect_pmid: PMID
  7568. + * @dect_lcn: logical connection number
  7569. + */
  7570. +struct sockaddr_dect_ssap {
  7571. + sa_family_t dect_family;
  7572. + __u8 dect_lln:4,
  7573. + dect_sapi:3;
  7574. + __u8 dect_class;
  7575. + int dect_index;
  7576. + __u64 dect_ari:40,
  7577. + dect_pmid:20,
  7578. + dect_lcn:3;
  7579. +};
  7580. +
  7581. +/* S-SAP primitives */
  7582. +#define DECT_DL_ENC_KEY 1
  7583. +#define DECT_DL_ENCRYPT 2
  7584. +#define DECT_DL_MAC_CONN_PARAMS 3
  7585. +
  7586. +enum dect_cipher_states {
  7587. + DECT_CIPHER_DISABLED,
  7588. + DECT_CIPHER_ENABLED,
  7589. +};
  7590. +
  7591. +/**
  7592. + * enum dect_mac_connection_types - MAC Connection types
  7593. + *
  7594. + * @DECT_MAC_CONN_BASIC: Basic connection, always I_N_min_delay service
  7595. + * @DECT_MAC_CONN_ADVANCED: Advanced connection
  7596. + * @DECT_MAC_CONN_COMPLEMENT: Complementary connection
  7597. + */
  7598. +enum dect_mac_connection_types {
  7599. + DECT_MAC_CONN_BASIC,
  7600. + DECT_MAC_CONN_ADVANCED,
  7601. + DECT_MAC_CONN_COMPLEMENT,
  7602. +};
  7603. +
  7604. +enum dect_mac_service_types {
  7605. + DECT_SERVICE_IN_MIN_DELAY = 0x0,
  7606. + DECT_SERVICE_IPX_ENCODED_PROTECTED = 0x1,
  7607. + DECT_SERVICE_IN_NORMAL_DELAY = 0x2,
  7608. + DECT_SERVICE_UNKNOWN = 0x4,
  7609. + DECT_SERVICE_C_CHANNEL_ONLY = 0x5,
  7610. + DECT_SERVICE_IP_ERROR_DETECTION = 0x10,
  7611. + DECT_SERVICE_IPQ_ERROR_DETECTION = 0x14,
  7612. + /* Lifetime encoded in low three bits */
  7613. + DECT_SERVICE_IP_ERROR_CORRECTION = 0x18,
  7614. + DECT_SERVICE_IPQ_ERROR_CORRECTION = 0x38,
  7615. +};
  7616. +
  7617. +/**
  7618. + * enum dect_slot_types - DECT slot types
  7619. + *
  7620. + * @DECT_FULL_SLOT: Full-slot format (480 bits)
  7621. + * @DECT_HALF_SLOT: Half-slot format (240 bits)
  7622. + * @DECT_DOUBLE_SLOT: Double-slot format (960 bits)
  7623. + * @DECT_LONG_SLOT_j640: Long slot format j=640 (800 bits)
  7624. + * @DECT_LONG_SLOT_j672: Long slot format j=672 (832 bits)
  7625. + *
  7626. + * The numeric values must match the MAC-layer attributes-T coding.
  7627. + */
  7628. +enum dect_slot_types {
  7629. + DECT_FULL_SLOT = 0x0,
  7630. + DECT_HALF_SLOT = 0x1,
  7631. + DECT_DOUBLE_SLOT = 0x2,
  7632. + DECT_LONG_SLOT_640 = 0x3,
  7633. + DECT_LONG_SLOT_672 = 0x4,
  7634. +};
  7635. +
  7636. +struct dect_mac_conn_params {
  7637. + enum dect_mac_connection_types type;
  7638. + enum dect_mac_service_types service;
  7639. + enum dect_slot_types slot;
  7640. +};
  7641. +
  7642. +/**
  7643. + * struct dect_dl_encrypt - DL_ENCRYPT primitive arguments
  7644. + *
  7645. + * @status: desired/achieved encryption status
  7646. + */
  7647. +struct dect_dl_encrypt {
  7648. + enum dect_cipher_states status;
  7649. +};
  7650. +
  7651. +/**
  7652. + * struct sockaddr_dect_lu - DLC U-plane LUx service instance address
  7653. + *
  7654. + * @dect_family: address family (AF_DECT)
  7655. + * @dect_mci: MAC Connection Identifier
  7656. + */
  7657. +struct sockaddr_dect_lu {
  7658. + sa_family_t dect_family;
  7659. + int dect_index;
  7660. + __u64 dect_ari:40,
  7661. + dect_pmid:20,
  7662. + dect_lcn:3;
  7663. +};
  7664. +
  7665. +/* LU1 SAP */
  7666. +
  7667. +#define DECT_LU1_QUEUE_STATS 0
  7668. +
  7669. +struct dect_lu1_queue_stats {
  7670. + __u32 rx_bytes;
  7671. + __u32 rx_underflow;
  7672. + __u32 tx_bytes;
  7673. + __u32 tx_underflow;
  7674. +};
  7675. +
  7676. +#endif /* _LINUX_DECT_H */
  7677. diff --git a/include/uapi/linux/dect_netlink.h b/include/uapi/linux/dect_netlink.h
  7678. new file mode 100644
  7679. index 0000000..7c01aca
  7680. --- /dev/null
  7681. +++ b/include/uapi/linux/dect_netlink.h
  7682. @@ -0,0 +1,397 @@
  7683. +#ifndef _LINUX_DECT_NETLINK_H
  7684. +#define _LINUX_DECT_NETLINK_H
  7685. +
  7686. +struct dectmsg {
  7687. + int dm_index;
  7688. +};
  7689. +
  7690. +enum dect_nlgroups {
  7691. + DECTNLGRP_NONE,
  7692. + DECTNLGRP_TRANSCEIVER,
  7693. + DECTNLGRP_CELL,
  7694. + DECTNLGRP_CLUSTER,
  7695. + DECTNLGRP_LLME,
  7696. + __DECTNLGRP_MAX
  7697. +};
  7698. +#define DECTNLGRP_MAX (__DECTNLGRP_MAX - 1)
  7699. +
  7700. +enum dect_netlink_msg_types {
  7701. + DECT_MSG_BASE = 0x10,
  7702. + DECT_NEW_TRANSCEIVER,
  7703. + DECT_DEL_TRANSCEIVER,
  7704. + DECT_GET_TRANSCEIVER,
  7705. + DECT_NEW_CELL,
  7706. + DECT_DEL_CELL,
  7707. + DECT_GET_CELL,
  7708. + DECT_NEW_CLUSTER,
  7709. + DECT_DEL_CLUSTER,
  7710. + DECT_GET_CLUSTER,
  7711. + DECT_LLME_MSG,
  7712. + __DECT_MSG_MAX
  7713. +};
  7714. +#define DECT_MSG_MAX (__DECT_MSG_MAX - 1)
  7715. +
  7716. +#define DECT_NR_MSGTYPES (DECT_MSG_MAX + 1 - DECT_MSG_BASE)
  7717. +
  7718. +enum dect_list_attrs {
  7719. + DECTA_LIST_UNSPEC,
  7720. + DECTA_LIST_ELEM,
  7721. + __DECTA_LIST_MAX
  7722. +};
  7723. +#define DECTA_LIST_MAX (__DECTA_LIST_MAX - 1)
  7724. +
  7725. +enum dect_slot_states {
  7726. + DECT_SLOT_IDLE,
  7727. + DECT_SLOT_SCANNING,
  7728. + DECT_SLOT_RX,
  7729. + DECT_SLOT_TX,
  7730. +};
  7731. +
  7732. +enum dect_slot_flags {
  7733. + DECT_SLOT_SYNC = 0x1,
  7734. + DECT_SLOT_CIPHER = 0x2,
  7735. +};
  7736. +
  7737. +/**
  7738. + * enum dect_packet_types - DECT Physical Packet Types
  7739. + *
  7740. + * @DECT_PACKET_P00: short physical packet P00, 96 bits, A-field only
  7741. + * @DECT_PACKET_P08: low capacity physical packet P08j, 180 bits
  7742. + * @DECT_PACKET_P32: basic physical packet P32, 420 bits
  7743. + * @DECT_PACKET_P80: high capacity physical packet P80, 900 bits
  7744. + * @DECT_PACKET_P640j: variable capacity packet P640j, 712 bits
  7745. + * @DECT_PACKET_P672j: variable capacity packet P640j, 744 bits
  7746. + */
  7747. +enum dect_packet_types {
  7748. + DECT_PACKET_P00,
  7749. + DECT_PACKET_P08,
  7750. + DECT_PACKET_P32,
  7751. + DECT_PACKET_P80,
  7752. + DECT_PACKET_P640j,
  7753. + DECT_PACKET_P672j,
  7754. + __DECT_PACKET_MAX
  7755. +};
  7756. +#define DECT_PACKET_MAX (__DECT_PACKET_MAX - 1)
  7757. +
  7758. +#define DECT_PHASE_OFFSET_SCALE 1024
  7759. +
  7760. +enum dect_slot_attrs {
  7761. + DECTA_SLOT_UNSPEC,
  7762. + DECTA_SLOT_NUM,
  7763. + DECTA_SLOT_STATE,
  7764. + DECTA_SLOT_FLAGS,
  7765. + DECTA_SLOT_PACKET,
  7766. + DECTA_SLOT_CARRIER,
  7767. + DECTA_SLOT_FREQUENCY,
  7768. + DECTA_SLOT_PHASEOFF,
  7769. + DECTA_SLOT_RSSI,
  7770. + DECTA_SLOT_RX_PACKETS,
  7771. + DECTA_SLOT_RX_BYTES,
  7772. + DECTA_SLOT_RX_A_CRC_ERRORS,
  7773. + DECTA_SLOT_RX_X_CRC_ERRORS,
  7774. + DECTA_SLOT_RX_Z_CRC_ERRORS,
  7775. + DECTA_SLOT_TX_PACKETS,
  7776. + DECTA_SLOT_TX_BYTES,
  7777. + __DECTA_SLOT_MAX
  7778. +};
  7779. +#define DECTA_SLOT_MAX (__DECTA_SLOT_MAX - 1)
  7780. +
  7781. +enum dect_transceiver_stats_attrs {
  7782. + DECTA_TRANSCEIVER_STATS_UNSPEC,
  7783. + DECTA_TRANSCEIVER_STATS_EVENT_BUSY,
  7784. + DECTA_TRANSCEIVER_STATS_EVENT_LATE,
  7785. + __DECTA_TRANSCEIVER_STATS_MAX
  7786. +};
  7787. +#define DECTA_TRANSCEIVER_STATS_MAX (__DECTA_TRANSCEIVER_STATS_MAX - 1)
  7788. +
  7789. +/**
  7790. + * @DECT_TRANSCEIVER_SLOW_HOPPING: transceiver has slow hopping radio
  7791. + * @DECT_TRANSCEIVER_PACKET_P64: transceiver supports packet P640j
  7792. + */
  7793. +enum dect_transceiver_features {
  7794. + DECT_TRANSCEIVER_SLOW_HOPPING = 0x1,
  7795. + DECT_TRANSCEIVER_PACKET_P64 = 0x2,
  7796. +};
  7797. +
  7798. +enum dect_transceiver_attrs {
  7799. + DECTA_TRANSCEIVER_UNSPEC,
  7800. + DECTA_TRANSCEIVER_NAME,
  7801. + DECTA_TRANSCEIVER_TYPE,
  7802. + DECTA_TRANSCEIVER_FEATURES,
  7803. + DECTA_TRANSCEIVER_LINK,
  7804. + DECTA_TRANSCEIVER_STATS,
  7805. + DECTA_TRANSCEIVER_BAND,
  7806. + DECTA_TRANSCEIVER_SLOTS,
  7807. + __DECTA_TRANSCEIVER_MAX
  7808. +};
  7809. +#define DECTA_TRANSCEIVER_MAX (__DECTA_TRANSCEIVER_MAX - 1)
  7810. +
  7811. +enum dect_cell_flags {
  7812. + DECT_CELL_CCP = (1 << 0),
  7813. + DECT_CELL_SLAVE = (1 << 1),
  7814. + DECT_CELL_MONITOR = (1 << 2),
  7815. +};
  7816. +
  7817. +enum dect_cell_attrs {
  7818. + DECTA_CELL_UNSPEC,
  7819. + DECTA_CELL_NAME,
  7820. + DECTA_CELL_FLAGS,
  7821. + DECTA_CELL_TRANSCEIVERS,
  7822. + DECTA_CELL_CLUSTER,
  7823. + __DECTA_CELL_MAX
  7824. +};
  7825. +#define DECTA_CELL_MAX (__DECTA_CELL_MAX - 1)
  7826. +
  7827. +enum dect_mbc_state {
  7828. + DECT_MBC_NONE,
  7829. + DECT_MBC_INITIATED,
  7830. + DECT_MBC_ESTABLISHED,
  7831. + DECT_MBC_RELEASED,
  7832. +};
  7833. +
  7834. +enum dect_mbc_tb_attrs {
  7835. + DECTA_MBC_TB_UNSPEC,
  7836. + DECTA_MBC_TB_LBN,
  7837. + DECTA_MBC_TB_ECN,
  7838. + DECTA_MBC_TB_CELL,
  7839. + DECTA_MBC_TB_RX_SLOT,
  7840. + DECTA_MBC_TB_TX_SLOT,
  7841. + __DECTA_MBC_TB_MAX,
  7842. +};
  7843. +#define DECTA_MBC_TB_MAX (__DECTA_MBC_TB_MAX - 1)
  7844. +
  7845. +enum dect_mbc_stats_attrs {
  7846. + DECTA_MBC_STATS_UNSPEC,
  7847. + DECTA_MBC_STATS_CS_RX_BYTES,
  7848. + DECTA_MBC_STATS_CS_TX_BYTES,
  7849. + DECTA_MBC_STATS_I_RX_BYTES,
  7850. + DECTA_MBC_STATS_I_TX_BYTES,
  7851. + DECTA_MBC_STATS_HANDOVERS,
  7852. + __DECTA_MBC_STATS_MAX,
  7853. +};
  7854. +#define DECTA_MBC_STATS_MAX (__DECTA_MBC_STATS_MAX - 1)
  7855. +
  7856. +enum dect_mbc_attrs {
  7857. + DECTA_MBC_UNSPEC,
  7858. + DECTA_MBC_MCEI,
  7859. + DECTA_MBC_SERVICE,
  7860. + DECTA_MBC_STATE,
  7861. + DECTA_MBC_CIPHER_STATE,
  7862. + DECTA_MBC_STATS,
  7863. + DECTA_MBC_TBS,
  7864. + __DECTA_MBC_MAX,
  7865. +};
  7866. +#define DECTA_MBC_MAX (__DECTA_MBC_MAX - 1)
  7867. +
  7868. +enum dect_cluster_attrs {
  7869. + DECTA_CLUSTER_UNSPEC,
  7870. + DECTA_CLUSTER_NAME,
  7871. + DECTA_CLUSTER_MODE,
  7872. + DECTA_CLUSTER_PARI,
  7873. + DECTA_CLUSTER_CELLS,
  7874. + DECTA_CLUSTER_MBCS,
  7875. + __DECTA_CLUSTER_MAX
  7876. +};
  7877. +#define DECTA_CLUSTER_MAX (__DECTA_CLUSTER_MAX - 1)
  7878. +
  7879. +enum dect_cluster_modes {
  7880. + DECT_MODE_FP,
  7881. + DECT_MODE_PP,
  7882. +};
  7883. +
  7884. +/**
  7885. + * DECT ARI classes
  7886. + *
  7887. + * @DECT_ARC_A: Residential and private (PBX) single- and small multiple cell systems
  7888. + * @DECT_ARC_B: Private (PABXs) multiple cell
  7889. + * @DECT_ARC_C: Public single and multiple cell systems
  7890. + * @DECT_ARC_D: Public DECT access to a GSM network
  7891. + * @DECT_ARC_E: PP to PP direct communication (private)
  7892. + */
  7893. +enum dect_ari_classes {
  7894. + DECT_ARC_A,
  7895. + DECT_ARC_B,
  7896. + DECT_ARC_C,
  7897. + DECT_ARC_D,
  7898. + DECT_ARC_E,
  7899. +};
  7900. +
  7901. +enum dect_ari_attrs {
  7902. + DECTA_ARI_UNSPEC,
  7903. + DECTA_ARI_CLASS,
  7904. + DECTA_ARI_FPN,
  7905. + DECTA_ARI_FPS,
  7906. + DECTA_ARI_EMC,
  7907. + DECTA_ARI_EIC,
  7908. + DECTA_ARI_POC,
  7909. + DECTA_ARI_GOP,
  7910. + DECTA_ARI_FIL,
  7911. + __DECTA_ARI_MAX
  7912. +};
  7913. +#define DECTA_ARI_MAX (__DECTA_ARI_MAX - 1)
  7914. +
  7915. +enum decta_sari_attrs {
  7916. + DECTA_SARI_UNSPEC,
  7917. + DECTA_SARI_ARI,
  7918. + DECTA_SARI_BLACK,
  7919. + DECTA_SARI_TARI,
  7920. + __DECTA_SARI_MAX
  7921. +};
  7922. +#define DECTA_SARI_MAX (__DECTA_SARI_MAX - 1)
  7923. +
  7924. +enum dect_fixed_part_capabilities {
  7925. + DECT_FPC_EXTENDED_FP_INFO = 0x80000,
  7926. + DECT_FPC_DOUBLE_DUPLEX_BEARER_CONNECTION= 0x40000,
  7927. + DECT_FPC_RESERVED = 0x20000,
  7928. + DECT_FPC_DOUBLE_SLOT = 0x10000,
  7929. + DECT_FPC_HALF_SLOT = 0x08000,
  7930. + DECT_FPC_FULL_SLOT = 0x04000,
  7931. + DECT_FPC_FREQ_CONTROL = 0x02000,
  7932. + DECT_FPC_PAGE_REPETITION = 0x01000,
  7933. + DECT_FPC_CO_SETUP_ON_DUMMY = 0x00800,
  7934. + DECT_FPC_CL_UPLINK = 0x00400,
  7935. + DECT_FPC_CL_DOWNLINK = 0x00200,
  7936. + DECT_FPC_BASIC_A_FIELD_SETUP = 0x00100,
  7937. + DECT_FPC_ADV_A_FIELD_SETUP = 0x00080,
  7938. + DECT_FPC_B_FIELD_SETUP = 0x00040,
  7939. + DECT_FPC_CF_MESSAGES = 0x00020,
  7940. + DECT_FPC_IN_MIN_DELAY = 0x00010,
  7941. + DECT_FPC_IN_NORM_DELAY = 0x00008,
  7942. + DECT_FPC_IP_ERROR_DETECTION = 0x00004,
  7943. + DECT_FPC_IP_ERROR_CORRECTION = 0x00002,
  7944. + DECT_FPC_MULTIBEARER_CONNECTIONS = 0x00001,
  7945. +};
  7946. +
  7947. +enum dect_higher_layer_capabilities {
  7948. + DECT_HLC_ADPCM_G721_VOICE = 0x8000,
  7949. + DECT_HLC_GAP_PAP_BASIC_SPEECH = 0x4000,
  7950. + DECT_HLC_NON_VOICE_CIRCUIT_SWITCHED = 0x2000,
  7951. + DECT_HLC_NON_VOICE_PACKET_SWITCHED = 0x1000,
  7952. + DECT_HLC_STANDARD_AUTHENTICATION = 0x0800,
  7953. + DECT_HLC_STANDARD_CIPHERING = 0x0400,
  7954. + DECT_HLC_LOCATION_REGISTRATION = 0x0200,
  7955. + DECT_HLC_SIM_SERVICES = 0x0100,
  7956. + DECT_HLC_NON_STATIC_FIXED_PART = 0x0080,
  7957. + DECT_HLC_CISS_SERVICE = 0x0040,
  7958. + DECT_HLC_CLMS_SERVICE = 0x0020,
  7959. + DECT_HLC_COMS_SERVICE = 0x0010,
  7960. + DECT_HLC_ACCESS_RIGHTS_REQUESTS = 0x0008,
  7961. + DECT_HLC_EXTERNAL_HANDOVER = 0x0004,
  7962. + DECT_HLC_CONNECTION_HANDOVER = 0x0002,
  7963. + DECT_HLC_RESERVED = 0x0001,
  7964. +};
  7965. +
  7966. +enum dect_extended_fixed_part_capabilities {
  7967. + DECT_EFPC_WRS_MASK = 0x1f80,
  7968. + DECT_EFPC_WRS_CRFP_HOPS_MASK = 0x1800,
  7969. + DECT_EFPC_WRS_CRFP_HOPS_1 = 0x0000,
  7970. + DECT_EFPC_WRS_CRFP_HOPS_2 = 0x0800,
  7971. + DECT_EFPC_WRS_CRFP_HOPS_3 = 0x1000,
  7972. + DECT_EFPC_WRS_CRFP_HOPS_NONE = 0x1800,
  7973. + DECT_EFPC_WRS_CRFP_ENCRYPTION = 0x0400,
  7974. + DECT_EFPC_WRS_REP_HOPS_MASK = 0x0300,
  7975. + DECT_EFPC_WRS_REP_HOPS_NONE = 0x0000,
  7976. + DECT_EFPC_WRS_REP_HOPS_1 = 0x0100,
  7977. + DECT_EFPC_WRS_REP_HOPS_2 = 0x0200,
  7978. + DECT_EFPC_WRS_REP_HOPS_3 = 0x0300,
  7979. + DECT_EFPC_WRS_REP_INTERLACING = 0x0080,
  7980. + DECT_EFPC_SYNC_MASK = 0x0060,
  7981. + DECT_EFPC_SYNC_PROLONGED_PREAMBLE = 0x0020,
  7982. + DECT_EFPC_SYNC_RESERVED1 = 0x0010,
  7983. + DECT_EFPC_MAC_SUSPEND_RESUME = 0x0008,
  7984. + DECT_EFPC_MAC_IP_Q_SERVICE = 0x0004,
  7985. + DECT_EFPC_EXTENDED_FP_INFO2 = 0x0002,
  7986. + DECT_EFPC_RESERVED2 = 0x0001,
  7987. +};
  7988. +
  7989. +enum dect_extended_higher_layer_capabilities {
  7990. + DECT_EHLC_ISDN_DATA_SERVICE = 0x000001,
  7991. + DECT_EHLC_DPRS_FREL = 0x000002,
  7992. + DECT_EHLC_DPRS_STREAM = 0x000004,
  7993. + DECT_EHLC_DATA_SERVICE_PROFILE_D = 0x000008,
  7994. + DECT_EHLC_LRMS = 0x000010,
  7995. + DECT_EHLC_ASYMETRIC_BEARERS = 0x000040,
  7996. + DECT_EHLC_EMERGENCY_CALLS = 0x000080,
  7997. + DECT_EHLC_TPUI_LOCATION_REGISTRATION = 0x000100,
  7998. + DECT_EHLC_GPS_SYNCHRONIZED = 0x000200,
  7999. + DECT_EHLC_ISDN_INTERMEDIATE_SYSTEM = 0x000400,
  8000. + DECT_EHLC_RAP_PART_1_PROFILE = 0x000800,
  8001. + DECT_EHLC_V_24 = 0x004000,
  8002. + DECT_EHLC_PPP = 0x008000,
  8003. + DECT_EHLC_IP = 0x010000,
  8004. + DECT_EHLC_TOKEN_RING = 0x020000,
  8005. + DECT_EHLC_ETHERNET = 0x040000,
  8006. + DECT_EHLC_IP_ROAMING = 0x080000,
  8007. + DECT_EHLC_GENERIC_MEDIA_ENCAPSULATION = 0x100000,
  8008. + DECT_EHLC_BASIC_ODAP = 0x200000,
  8009. + DECT_EHLC_F_MMS_INTERWORKING_PROFILE = 0x400000,
  8010. +};
  8011. +
  8012. +enum dect_extended_fixed_part_capabilities2 {
  8013. + DECT_EFPC2_LONG_SLOT_J640 = 0x800,
  8014. + DECT_EFPC2_LONG_SLOT_J672 = 0x400,
  8015. + DECT_EFPC2_IP_F = 0x200,
  8016. + DECT_EFPC2_SI_PF = 0x100,
  8017. + DECT_EFPC2_GF = 0x080,
  8018. + DECT_EFPC2_NO_EMISSION_CARRIER = 0x001,
  8019. +};
  8020. +
  8021. +enum dect_extended_higher_layer_capabilities2 {
  8022. + DECT_EHLC2_NG_DECT_PERMANENT_CLIR = 0x000100,
  8023. + DECT_EHLC2_NG_DECT_MULTIPLE_CALLS = 0x000200,
  8024. + DECT_EHLC2_NG_DECT_MULTIPLE_LINES = 0x000400,
  8025. + DECT_EHLC2_EASY_PAIRING = 0x000800,
  8026. + DECT_EHLC2_LIST_ACCESS_FEATURES = 0x001000,
  8027. + DECT_EHLC2_NO_EMISSION_MODE = 0x002000,
  8028. + DECT_EHLC2_NG_DECT_CALL_DEFLECTION = 0x004000,
  8029. + DECT_EHLC2_NG_DECT_INTRUSION_CALL = 0x008000,
  8030. + DECT_EHLC2_NG_DECT_CONFERENCE_CALL = 0x010000,
  8031. + DECT_EHLC2_NG_DECT_PARALLEL_CALLS = 0x020000,
  8032. + DECT_EHLC2_NG_DECT_CALL_TRANSFER = 0x040000,
  8033. + DECT_EHLC2_NG_DECT_EXTENDED_WIDEBAND = 0x080000,
  8034. + DECT_EHLC2_PACKET_DATA_CATEGORY_MASK = 0x700000,
  8035. + DECT_EHLC2_NG_DECT_WIDEBAND = 0x800000,
  8036. +};
  8037. +
  8038. +enum dect_mac_info_attrs {
  8039. + DECTA_MAC_INFO_UNSPEC,
  8040. + DECTA_MAC_INFO_PARI,
  8041. + DECTA_MAC_INFO_RPN,
  8042. + DECTA_MAC_INFO_RSSI,
  8043. + DECTA_MAC_INFO_SARI_LIST,
  8044. + DECTA_MAC_INFO_FPC,
  8045. + DECTA_MAC_INFO_HLC,
  8046. + DECTA_MAC_INFO_EFPC,
  8047. + DECTA_MAC_INFO_EHLC,
  8048. + DECTA_MAC_INFO_EFPC2,
  8049. + DECTA_MAC_INFO_EHLC2,
  8050. + DECTA_MAC_INFO_MFN,
  8051. + __DECTA_MAC_INFO_MAX
  8052. +};
  8053. +#define DECTA_MAC_INFO_MAX (__DECTA_MAC_INFO_MAX - 1)
  8054. +
  8055. +enum dect_llme_ops {
  8056. + DECT_LLME_REQUEST,
  8057. + DECT_LLME_INDICATE,
  8058. + DECT_LLME_RESPONSE,
  8059. + DECT_LLME_CONFIRM,
  8060. +};
  8061. +
  8062. +enum dect_llme_msg_types {
  8063. + DECT_LLME_SCAN,
  8064. + DECT_LLME_MAC_INFO,
  8065. + DECT_LLME_MAC_RFP_PRELOAD,
  8066. + __DECT_LLME_MAX
  8067. +};
  8068. +#define DECT_LLME_MAX (__DECT_LLME_MAX - 1)
  8069. +
  8070. +enum dect_llme_msg_attrs {
  8071. + DECTA_LLME_UNSPEC,
  8072. + DECTA_LLME_OP,
  8073. + DECTA_LLME_TYPE,
  8074. + DECTA_LLME_DATA,
  8075. + __DECTA_LLME_MAX
  8076. +};
  8077. +#define DECTA_LLME_MAX (__DECTA_LLME_MAX - 1)
  8078. +
  8079. +#endif /* _LINUX_DECT_NETLINK_H */
  8080. diff --git a/include/uapi/linux/netlink.h b/include/uapi/linux/netlink.h
  8081. index 0dba4e4..fc9183e 100644
  8082. --- a/include/uapi/linux/netlink.h
  8083. +++ b/include/uapi/linux/netlink.h
  8084. @@ -27,6 +27,7 @@
  8085. #define NETLINK_ECRYPTFS 19
  8086. #define NETLINK_RDMA 20
  8087. #define NETLINK_CRYPTO 21 /* Crypto layer */
  8088. +#define NETLINK_DECT 22 /* DECT */
  8090. #define NETLINK_INET_DIAG NETLINK_SOCK_DIAG
  8092. diff --git a/net/Kconfig b/net/Kconfig
  8093. index 7b6cd34..7aee66b 100644
  8094. --- a/net/Kconfig
  8095. +++ b/net/Kconfig
  8096. @@ -367,6 +367,7 @@ source "net/ax25/Kconfig"
  8097. source "net/can/Kconfig"
  8098. source "net/irda/Kconfig"
  8099. source "net/bluetooth/Kconfig"
  8100. +source "net/dect/Kconfig"
  8101. source "net/rxrpc/Kconfig"
  8102. source "net/kcm/Kconfig"
  8103. source "net/strparser/Kconfig"
  8104. diff --git a/net/Makefile b/net/Makefile
  8105. index 4cafaa2..986de8b 100644
  8106. --- a/net/Makefile
  8107. +++ b/net/Makefile
  8108. @@ -32,6 +32,7 @@ obj-$(CONFIG_AX25) += ax25/
  8109. obj-$(CONFIG_CAN) += can/
  8110. obj-$(CONFIG_IRDA) += irda/
  8111. obj-$(CONFIG_BT) += bluetooth/
  8112. +obj-$(CONFIG_DECT) += dect/
  8113. obj-$(CONFIG_SUNRPC) += sunrpc/
  8114. obj-$(CONFIG_AF_RXRPC) += rxrpc/
  8115. obj-$(CONFIG_AF_KCM) += kcm/
  8116. diff --git a/net/core/sock.c b/net/core/sock.c
  8117. index 5e3ca41..f984e6c 100644
  8118. --- a/net/core/sock.c
  8119. +++ b/net/core/sock.c
  8120. @@ -222,7 +222,7 @@ static const char *const af_family_key_strings[AF_MAX+1] = {
  8121. "sk_lock-AF_RXRPC" , "sk_lock-AF_ISDN" , "sk_lock-AF_PHONET" ,
  8122. "sk_lock-AF_IEEE802154", "sk_lock-AF_CAIF" , "sk_lock-AF_ALG" ,
  8123. "sk_lock-AF_NFC" , "sk_lock-AF_VSOCK" , "sk_lock-AF_KCM" ,
  8124. - "sk_lock-AF_MAX"
  8125. + "sk_lock-AF_DECT" , "sk_lock-AF_MAX"
  8126. };
  8127. static const char *const af_family_slock_key_strings[AF_MAX+1] = {
  8128. "slock-AF_UNSPEC", "slock-AF_UNIX" , "slock-AF_INET" ,
  8129. @@ -239,7 +239,7 @@ static const char *const af_family_slock_key_strings[AF_MAX+1] = {
  8130. "slock-AF_RXRPC" , "slock-AF_ISDN" , "slock-AF_PHONET" ,
  8131. "slock-AF_IEEE802154", "slock-AF_CAIF" , "slock-AF_ALG" ,
  8132. "slock-AF_NFC" , "slock-AF_VSOCK" ,"slock-AF_KCM" ,
  8133. - "slock-AF_MAX"
  8134. + "slock-AF_DECT" , "slock-AF_MAX"
  8135. };
  8136. static const char *const af_family_clock_key_strings[AF_MAX+1] = {
  8137. "clock-AF_UNSPEC", "clock-AF_UNIX" , "clock-AF_INET" ,
  8138. @@ -256,7 +256,7 @@ static const char *const af_family_clock_key_strings[AF_MAX+1] = {
  8139. "clock-AF_RXRPC" , "clock-AF_ISDN" , "clock-AF_PHONET" ,
  8140. "clock-AF_IEEE802154", "clock-AF_CAIF" , "clock-AF_ALG" ,
  8141. "clock-AF_NFC" , "clock-AF_VSOCK" , "clock-AF_KCM" ,
  8142. - "clock-AF_MAX"
  8143. + "clock-AF_DECT" , "clock-AF_MAX"
  8144. };
  8146. /*
  8147. diff --git a/net/core/sock.c.rej b/net/core/sock.c.rej
  8148. new file mode 100644
  8149. index 0000000..1a51eb7
  8150. --- /dev/null
  8151. +++ b/net/core/sock.c.rej
  8152. @@ -0,0 +1,32 @@
  8153. +--- net/core/sock.c
  8154. ++++ net/core/sock.c
  8155. +@@ -221,7 +221,8 @@ static const char *const af_family_key_strings[AF_MAX+1] = {
  8156. + "sk_lock-AF_TIPC" , "sk_lock-AF_BLUETOOTH", "sk_lock-IUCV" ,
  8157. + "sk_lock-AF_RXRPC" , "sk_lock-AF_ISDN" , "sk_lock-AF_PHONET" ,
  8158. + "sk_lock-AF_IEEE802154", "sk_lock-AF_CAIF" , "sk_lock-AF_ALG" ,
  8159. +- "sk_lock-AF_NFC" , "sk_lock-AF_VSOCK" , "sk_lock-AF_MAX"
  8160. ++ "sk_lock-AF_NFC" , "sk_lock-AF_VSOCK" , "sk_lock-AF_DECT" ,
  8161. ++ "sk_lock-AF_MAX"
  8162. + };
  8163. + static const char *const af_family_slock_key_strings[AF_MAX+1] = {
  8164. + "slock-AF_UNSPEC", "slock-AF_UNIX" , "slock-AF_INET" ,
  8165. +@@ -237,7 +238,8 @@ static const char *const af_family_slock_key_strings[AF_MAX+1] = {
  8166. + "slock-AF_TIPC" , "slock-AF_BLUETOOTH", "slock-AF_IUCV" ,
  8167. + "slock-AF_RXRPC" , "slock-AF_ISDN" , "slock-AF_PHONET" ,
  8168. + "slock-AF_IEEE802154", "slock-AF_CAIF" , "slock-AF_ALG" ,
  8169. +- "slock-AF_NFC" , "slock-AF_VSOCK" ,"slock-AF_MAX"
  8170. ++ "slock-AF_NFC" , "slock-AF_VSOCK" , "slock-AF_DECT" ,
  8171. ++ "slock-AF_MAX"
  8172. + };
  8173. + static const char *const af_family_clock_key_strings[AF_MAX+1] = {
  8174. + "clock-AF_UNSPEC", "clock-AF_UNIX" , "clock-AF_INET" ,
  8175. +@@ -253,7 +255,8 @@ static const char *const af_family_clock_key_strings[AF_MAX+1] = {
  8176. + "clock-AF_TIPC" , "clock-AF_BLUETOOTH", "clock-AF_IUCV" ,
  8177. + "clock-AF_RXRPC" , "clock-AF_ISDN" , "clock-AF_PHONET" ,
  8178. + "clock-AF_IEEE802154", "clock-AF_CAIF" , "clock-AF_ALG" ,
  8179. +- "clock-AF_NFC" , "clock-AF_VSOCK" , "clock-AF_MAX"
  8180. ++ "clock-AF_NFC" , "clock-AF_VSOCK" , "clock-AF_DECT" ,
  8181. ++ "clock-AF_MAX"
  8182. + };
  8183. +
  8184. + /*
  8185. diff --git a/net/dect/Kconfig b/net/dect/Kconfig
  8186. new file mode 100644
  8187. index 0000000..873500d
  8188. --- /dev/null
  8189. +++ b/net/dect/Kconfig
  8190. @@ -0,0 +1,66 @@
  8191. +menuconfig DECT
  8192. + tristate "DECT protocol support"
  8193. + help
  8194. + This option enables support for the DECT protocol.
  8195. +
  8196. + If unsure, say N.
  8197. +
  8198. +if DECT
  8199. +
  8200. +config DECT_DEBUG
  8201. + bool "DECT debugging"
  8202. + help
  8203. + This option enables support for debugging in the DECT modules.
  8204. +
  8205. + If unsure, say N.
  8206. +
  8207. +config DECT_CSF
  8208. + tristate "DECT Cell Site Functions (CSF) support"
  8209. + help
  8210. + This option enables support for DECT Cell Site Functions. A DECT
  8211. + cell is a radio endpoint containing one or more transceivers.
  8212. +
  8213. + If unsure, say N.
  8214. +
  8215. +config DECT_RAW
  8216. + tristate "DECT raw sockets"
  8217. + depends on DECT_CSF
  8218. + help
  8219. + This option enables support for PF_DECT raw sockets. DECT raw
  8220. + sockets are used to receive raw frames from DECT devices.
  8221. +
  8222. + If unsure, say N.
  8223. +
  8224. +config DECT_CCF
  8225. + tristate "DECT Cluster Control Functions (CCF) support"
  8226. + help
  8227. + This option enables support for the DECT Cluster Control Functions.
  8228. +
  8229. + A DECT cluster is a Portable radio Termination (PT), containing a
  8230. + single cell, or a Fixed radio Termination (FT), containing up to
  8231. + 8 cells.
  8232. +
  8233. + If unsure, say N.
  8234. +
  8235. +config DECT_LU1_SAP
  8236. + tristate "DECT DLC LU1 SAP sockets"
  8237. + select DECT_CCF
  8238. + help
  8239. + This option enables support for PF_DECT DLC LU1 SAP sockets. DECT
  8240. + DLC LU1 SAP sockets are used for the TRUP (TRansparent UnProtected)
  8241. + service, most commonly used for audio.
  8242. +
  8243. + If unsure, say N.
  8244. +
  8245. +config DECT_CCP
  8246. + bool "DECT Cell Control Protocol support"
  8247. + depends on DECT_CSF || DECT_CCF
  8248. + select TIPC
  8249. + help
  8250. + This option enables support for the DECT Cell Control Protocol.
  8251. + This can be used to remotely control one or multiple DECT cells
  8252. + by the DECT cluster control functions.
  8253. +
  8254. + If unsure, say N.
  8255. +
  8256. +endif
  8257. diff --git a/net/dect/Makefile b/net/dect/Makefile
  8258. new file mode 100644
  8259. index 0000000..7d7bb14
  8260. --- /dev/null
  8261. +++ b/net/dect/Makefile
  8262. @@ -0,0 +1,17 @@
  8263. +dect-y += core.o identities.o dect_netlink.o af_dect.o
  8264. +
  8265. +dect_csf-y += mac_csf.o transceiver.o
  8266. +
  8267. +dect_ccf-y += mac_ccf.o dsc.o
  8268. +dect_ccf-y += dlc.o
  8269. +dect_ccf-y += dlc_cplane.o dlc_b_sap.o dlc_s_sap.o
  8270. +dect_ccf-y += dlc_uplane.o
  8271. +dect_ccf-$(CONFIG_DECT_CCP) += ccp.o
  8272. +
  8273. +dect_raw-y += raw.o
  8274. +
  8275. +obj-$(CONFIG_DECT) += dect.o
  8276. +obj-$(CONFIG_DECT_CSF) += dect_csf.o
  8277. +obj-$(CONFIG_DECT_RAW) += dect_raw.o
  8278. +obj-$(CONFIG_DECT_CCF) += dect_ccf.o
  8279. +obj-$(CONFIG_DECT_LU1_SAP) += dlc_lu1_sap.o
  8280. diff --git a/net/dect/af_dect.c b/net/dect/af_dect.c
  8281. new file mode 100644
  8282. index 0000000..a6dd709
  8283. --- /dev/null
  8284. +++ b/net/dect/af_dect.c
  8285. @@ -0,0 +1,456 @@
  8286. +/*
  8287. + * DECT sockets
  8288. + *
  8289. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  8290. + *
  8291. + * This program is free software; you can redistribute it and/or modify
  8292. + * it under the terms of the GNU General Public License version 2 as
  8293. + * published by the Free Software Foundation.
  8294. + */
  8295. +
  8296. +#include <linux/kernel.h>
  8297. +#include <linux/module.h>
  8298. +#include <linux/init.h>
  8299. +#include <linux/spinlock.h>
  8300. +#include <linux/socket.h>
  8301. +#include <linux/net.h>
  8302. +#include <linux/poll.h>
  8303. +#include <linux/dect.h>
  8304. +#include <net/sock.h>
  8305. +#include <net/dect/dect.h>
  8306. +
  8307. +static struct dect_proto *dect_protos[DECT_PROTO_NUM];
  8308. +static DEFINE_SPINLOCK(dect_proto_lock);
  8309. +
  8310. +void (*dect_raw_rcv_hook)(struct sk_buff *skb);
  8311. +EXPORT_SYMBOL_GPL(dect_raw_rcv_hook);
  8312. +
  8313. +int dect_proto_register(struct dect_proto *proto)
  8314. +{
  8315. + int err;
  8316. +
  8317. + err = proto_register(&proto->proto, true);
  8318. + if (err < 0)
  8319. + return err;
  8320. +
  8321. + spin_lock(&dect_proto_lock);
  8322. + dect_protos[proto->protocol] = proto;
  8323. + spin_unlock(&dect_proto_lock);
  8324. + return 0;
  8325. +}
  8326. +EXPORT_SYMBOL_GPL(dect_proto_register);
  8327. +
  8328. +void dect_proto_unregister(struct dect_proto *proto)
  8329. +{
  8330. + spin_lock(&dect_proto_lock);
  8331. + dect_protos[proto->protocol] = NULL;
  8332. + spin_unlock(&dect_proto_lock);
  8333. + proto_unregister(&proto->proto);
  8334. +}
  8335. +EXPORT_SYMBOL_GPL(dect_proto_unregister);
  8336. +
  8337. +struct sk_buff *dect_alloc_notification(u32 type, const void *data,
  8338. + unsigned int size)
  8339. +{
  8340. + struct sk_buff *skb;
  8341. +
  8342. + skb = alloc_skb(size, GFP_ATOMIC);
  8343. + if (skb == NULL)
  8344. + return NULL;
  8345. + DECT_NOTIFY_CB(skb)->type = type;
  8346. + memcpy(skb_put(skb, size), data, size);
  8347. + return skb;
  8348. +}
  8349. +EXPORT_SYMBOL_GPL(dect_alloc_notification);
  8350. +
  8351. +static void dect_destruct(struct sock *sk)
  8352. +{
  8353. + __skb_queue_purge(&sk->sk_receive_queue);
  8354. + __skb_queue_purge(&sk->sk_error_queue);
  8355. + __skb_queue_purge(&sk->sk_write_queue);
  8356. +}
  8357. +
  8358. +static int dect_release(struct socket *sock)
  8359. +{
  8360. + struct sock *sk = sock->sk;
  8361. + long timeout;
  8362. +
  8363. + if (sk == NULL)
  8364. + return 0;
  8365. +
  8366. + timeout = 0;
  8367. + if (sock_flag(sk, SOCK_LINGER) && !(current->flags & PF_EXITING))
  8368. + timeout = sk->sk_lingertime;
  8369. + sock->sk = NULL;
  8370. + sk->sk_prot->close(sk, timeout);
  8371. + return 0;
  8372. +}
  8373. +
  8374. +static int dect_bind(struct socket *sock, struct sockaddr *uaddr, int len)
  8375. +{
  8376. + struct sock *sk = sock->sk;
  8377. + int err;
  8378. +
  8379. + err = 0;
  8380. + if (sk->sk_prot->bind != NULL)
  8381. + err = sk->sk_prot->bind(sk, uaddr, len);
  8382. +
  8383. + return err;
  8384. +}
  8385. +
  8386. +static int dect_listen(struct socket *sock, int backlog)
  8387. +{
  8388. + struct sock *sk = sock->sk;
  8389. + int err;
  8390. +
  8391. + lock_sock(sk);
  8392. + err = -EINVAL;
  8393. + if (sock->state != SS_UNCONNECTED ||
  8394. + (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET))
  8395. + goto out;
  8396. +
  8397. + if (sk->sk_state != DECT_SK_RELEASED && sk->sk_state != DECT_SK_LISTEN)
  8398. + goto out;
  8399. +
  8400. + if (sk->sk_state != DECT_SK_LISTEN)
  8401. + sk->sk_prot->hash(sk);
  8402. + sk->sk_max_ack_backlog = backlog;
  8403. + err = 0;
  8404. +out:
  8405. + release_sock(sk);
  8406. + return err;
  8407. +}
  8408. +
  8409. +static int dect_accept(struct socket *sock, struct socket *newsock, int flags)
  8410. +{
  8411. + struct sock *sk = sock->sk, *newsk;
  8412. + int err;
  8413. +
  8414. + newsk = sk->sk_prot->accept(sk, flags, &err);
  8415. + if (newsk == NULL)
  8416. + return err;
  8417. +
  8418. + lock_sock(newsk);
  8419. + sock_graft(newsk, newsock);
  8420. + newsock->state = SS_CONNECTED;
  8421. + release_sock(newsk);
  8422. + return 0;
  8423. +}
  8424. +
  8425. +static unsigned int dect_poll(struct file *file, struct socket *sock,
  8426. + struct poll_table_struct *wait)
  8427. +{
  8428. + struct sock *sk = sock->sk;
  8429. + unsigned int mask;
  8430. +
  8431. + poll_wait(file, sk_sleep(sk), wait);
  8432. + mask = 0;
  8433. +
  8434. + if (sk->sk_state == DECT_SK_LISTEN) {
  8435. + if (!hlist_empty(&dect_csk(sk)->accept_queue))
  8436. + return POLLIN | POLLRDNORM;
  8437. + return 0;
  8438. + }
  8439. +
  8440. + /* exceptional events? */
  8441. + if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
  8442. + mask |= POLLERR;
  8443. + if (sk->sk_shutdown & RCV_SHUTDOWN)
  8444. + mask |= POLLRDHUP;
  8445. + if (sk->sk_shutdown == SHUTDOWN_MASK)
  8446. + mask |= POLLHUP;
  8447. +
  8448. + /* readable? */
  8449. + if (!skb_queue_empty(&sk->sk_receive_queue) ||
  8450. + (sk->sk_shutdown & RCV_SHUTDOWN))
  8451. + mask |= POLLIN | POLLRDNORM;
  8452. +
  8453. + /* Connection-based need to check for termination and startup */
  8454. + if (sk->sk_state == DECT_SK_RELEASED)
  8455. + mask |= POLLHUP;
  8456. + /* connection hasn't started yet? */
  8457. + if (sk->sk_state == DECT_SK_ESTABLISH_PENDING)
  8458. + return mask;
  8459. +
  8460. + /* writable? */
  8461. + if (sock_writeable(sk))
  8462. + mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
  8463. + else
  8464. + set_bit(SOCKWQ_ASYNC_NOSPACE, &sk->sk_socket->flags);
  8465. +
  8466. + return mask;
  8467. +}
  8468. +
  8469. +static int dect_shutdown(struct socket *sock, int how)
  8470. +{
  8471. + struct sock *sk = sock->sk;
  8472. + int err = 0;
  8473. +
  8474. + how++;
  8475. + if ((how & ~SHUTDOWN_MASK) || !how)
  8476. + return -EINVAL;
  8477. +
  8478. + lock_sock(sk);
  8479. +
  8480. + if (sock->state == SS_CONNECTING &&
  8481. + sk->sk_state == DECT_SK_ESTABLISH_PENDING)
  8482. + sock->state = SS_DISCONNECTING;
  8483. +
  8484. + switch (sk->sk_state) {
  8485. + case DECT_SK_RELEASED:
  8486. + err = -ENOTCONN;
  8487. + break;
  8488. + case DECT_SK_LISTEN:
  8489. + if (!(how & RCV_SHUTDOWN))
  8490. + break;
  8491. + default:
  8492. + sk->sk_shutdown |= how;
  8493. + if (sk->sk_prot->shutdown != NULL)
  8494. + sk->sk_prot->shutdown(sk, how);
  8495. + }
  8496. +
  8497. + /* wake up processes sleeping in poll() */
  8498. + sk->sk_state_change(sk);
  8499. + release_sock(sk);
  8500. + return err;
  8501. +}
  8502. +
  8503. +static int dect_connect(struct socket *sock, struct sockaddr *uaddr, int len,
  8504. + int flags)
  8505. +{
  8506. + struct sock *sk = sock->sk;
  8507. + long timeo;
  8508. + int err;
  8509. +
  8510. + lock_sock(sk);
  8511. + switch (sock->state) {
  8512. + case SS_CONNECTED:
  8513. + err = -EISCONN;
  8514. + goto out;
  8515. + case SS_CONNECTING:
  8516. + err = -EALREADY;
  8517. + goto out;
  8518. + case SS_UNCONNECTED:
  8519. + err = -EISCONN;
  8520. + if (sk->sk_state != DECT_SK_RELEASED)
  8521. + goto out;
  8522. + err = sk->sk_prot->connect(sk, uaddr, len);
  8523. + if (err < 0)
  8524. + goto out;
  8525. + sock->state = SS_CONNECTING;
  8526. + err = -EINPROGRESS;
  8527. + break;
  8528. + default:
  8529. + err = -EINVAL;
  8530. + goto out;
  8531. + }
  8532. +
  8533. + if (sk->sk_state == DECT_SK_ESTABLISH_PENDING) {
  8534. + timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
  8535. + err = sk_stream_wait_connect(sk, &timeo);
  8536. + if (err < 0)
  8537. + goto out;
  8538. +
  8539. + err = sock_intr_errno(timeo);
  8540. + if (signal_pending(current))
  8541. + goto out;
  8542. + }
  8543. +
  8544. + /* Connection establishment was aborted or failed */
  8545. + if (sk->sk_state == DECT_SK_RELEASED)
  8546. + goto sock_error;
  8547. +
  8548. + sock->state = SS_CONNECTED;
  8549. + err = 0;
  8550. +out:
  8551. + release_sock(sk);
  8552. + return err;
  8553. +
  8554. +sock_error:
  8555. + err = sock_error(sk) ? : -ECONNABORTED;
  8556. + sock->state = SS_UNCONNECTED;
  8557. + goto out;
  8558. +}
  8559. +
  8560. +static int dect_getname(struct socket *sock, struct sockaddr *uaddr, int *len,
  8561. + int peer)
  8562. +{
  8563. + const struct dect_proto *p;
  8564. +
  8565. + /* AF_DECT uses different address formats for the different SAPs */
  8566. + p = container_of(sock->sk->sk_prot, struct dect_proto, proto);
  8567. + if (p->getname != NULL)
  8568. + return p->getname(sock->sk, uaddr, len, peer);
  8569. + *len = 0;
  8570. + return 0;
  8571. +}
  8572. +
  8573. +static int dect_sendmsg(struct socket *sock,
  8574. + struct msghdr *msg, size_t size)
  8575. +{
  8576. + struct sock *sk = sock->sk;
  8577. +
  8578. + return sk->sk_prot->sendmsg(sk, msg, size);
  8579. +}
  8580. +
  8581. +static int dect_setsockopt(struct socket *sock, int level, int optname,
  8582. + char __user *optval, unsigned int optlen)
  8583. +{
  8584. + struct sock *sk = sock->sk;
  8585. + int err;
  8586. +
  8587. + if (level != SOL_DECT)
  8588. + return -ENOPROTOOPT;
  8589. +
  8590. + switch (optname) {
  8591. + default:
  8592. + if (sk->sk_prot->setsockopt)
  8593. + err = sk->sk_prot->setsockopt(sk, level, optname,
  8594. + optval, optlen);
  8595. + else
  8596. + err = -ENOPROTOOPT;
  8597. + }
  8598. + return err;
  8599. +}
  8600. +
  8601. +static int dect_getsockopt(struct socket *sock, int level, int optname,
  8602. + char __user *optval, int __user *optlen)
  8603. +{
  8604. + struct sock *sk = sock->sk;
  8605. + int err;
  8606. +
  8607. + if (level != SOL_DECT)
  8608. + return -ENOPROTOOPT;
  8609. +
  8610. + switch (optname) {
  8611. + default:
  8612. + if (sk->sk_prot->getsockopt)
  8613. + err = sk->sk_prot->getsockopt(sk, level, optname,
  8614. + optval, optlen);
  8615. + else
  8616. + err = -ENOPROTOOPT;
  8617. + }
  8618. + return err;
  8619. +}
  8620. +
  8621. +static int dect_create(struct net *net, struct socket *sock, int protocol,
  8622. + int kern)
  8623. +{
  8624. + struct dect_proto *p;
  8625. + struct sock *sk;
  8626. + int err = 0;
  8627. +
  8628. + if (protocol < 0 || protocol >= DECT_PROTO_NUM)
  8629. + return -EPROTONOSUPPORT;
  8630. +#ifdef CONFIG_MODULES
  8631. + if (dect_protos[protocol] == NULL) {
  8632. + err = request_module("net-pf-%d-proto-%d", PF_DECT, protocol);
  8633. + if (err < 0)
  8634. + return err;
  8635. + }
  8636. +#endif
  8637. + spin_lock(&dect_proto_lock);
  8638. + p = dect_protos[protocol];
  8639. + if (p != NULL && !try_module_get(p->proto.owner))
  8640. + p = NULL;
  8641. + spin_unlock(&dect_proto_lock);
  8642. +
  8643. + if (p == NULL)
  8644. + return -EPROTONOSUPPORT;
  8645. +
  8646. + if (p->type != sock->type) {
  8647. + err = -EPROTONOSUPPORT;
  8648. + goto err;
  8649. + }
  8650. +
  8651. + if (cap_valid(p->capability) && !capable(p->capability)) {
  8652. + err = -EACCES;
  8653. + goto err;
  8654. + }
  8655. +
  8656. + sock->state = SS_UNCONNECTED;
  8657. + sock->ops = p->ops;
  8658. +
  8659. + sk = sk_alloc(net, PF_DECT, GFP_KERNEL, &p->proto, kern);
  8660. + if (sk == NULL) {
  8661. + err = -ENOMEM;
  8662. + goto err;
  8663. + }
  8664. +
  8665. + sock_init_data(sock, sk);
  8666. + sk->sk_protocol = protocol;
  8667. + sk->sk_destruct = dect_destruct;
  8668. +
  8669. + if (sk->sk_prot->init != NULL) {
  8670. + err = sk->sk_prot->init(sk);
  8671. + if (err < 0) {
  8672. + sock_orphan(sk);
  8673. + sock_put(sk);
  8674. + }
  8675. + }
  8676. +err:
  8677. + module_put(p->proto.owner);
  8678. + return err;
  8679. +}
  8680. +
  8681. +const struct proto_ops dect_stream_ops = {
  8682. + .family = PF_DECT,
  8683. + .owner = THIS_MODULE,
  8684. + .release = dect_release,
  8685. + .bind = dect_bind,
  8686. + .connect = dect_connect,
  8687. + .socketpair = sock_no_socketpair,
  8688. + .getname = dect_getname,
  8689. + .poll = dect_poll,
  8690. + .ioctl = sock_no_ioctl,
  8691. + .listen = dect_listen,
  8692. + .accept = dect_accept,
  8693. + .shutdown = dect_shutdown,
  8694. + .setsockopt = dect_setsockopt,
  8695. + .getsockopt = dect_getsockopt,
  8696. + .sendmsg = dect_sendmsg,
  8697. + .recvmsg = sock_common_recvmsg,
  8698. + .mmap = sock_no_mmap,
  8699. + .sendpage = sock_no_sendpage,
  8700. +};
  8701. +EXPORT_SYMBOL_GPL(dect_stream_ops);
  8702. +
  8703. +const struct proto_ops dect_dgram_ops = {
  8704. + .family = PF_DECT,
  8705. + .owner = THIS_MODULE,
  8706. + .release = dect_release,
  8707. + .bind = dect_bind,
  8708. + .connect = sock_no_connect,
  8709. + .socketpair = sock_no_socketpair,
  8710. + .getname = dect_getname,
  8711. + .poll = datagram_poll,
  8712. + .ioctl = sock_no_ioctl,
  8713. + .listen = sock_no_listen,
  8714. + .accept = sock_no_accept,
  8715. + .shutdown = sock_no_shutdown,
  8716. + .setsockopt = sock_no_setsockopt,
  8717. + .getsockopt = sock_no_getsockopt,
  8718. + .sendmsg = dect_sendmsg,
  8719. + .recvmsg = sock_common_recvmsg,
  8720. + .mmap = sock_no_mmap,
  8721. + .sendpage = sock_no_sendpage,
  8722. +};
  8723. +EXPORT_SYMBOL_GPL(dect_dgram_ops);
  8724. +
  8725. +static struct net_proto_family dect_family_ops = {
  8726. + .family = PF_DECT,
  8727. + .create = dect_create,
  8728. + .owner = THIS_MODULE,
  8729. +};
  8730. +
  8731. +int __init dect_af_module_init(void)
  8732. +{
  8733. + return sock_register(&dect_family_ops);
  8734. +}
  8735. +
  8736. +void dect_af_module_exit(void)
  8737. +{
  8738. + sock_unregister(PF_DECT);
  8739. +}
  8740. +
  8741. +MODULE_ALIAS_NETPROTO(PF_DECT);
  8742. diff --git a/net/dect/ccp.c b/net/dect/ccp.c
  8743. new file mode 100644
  8744. index 0000000..c8903ad
  8745. --- /dev/null
  8746. +++ b/net/dect/ccp.c
  8747. @@ -0,0 +1,906 @@
  8748. +/*
  8749. + * DECT Cell Control Protocol
  8750. + *
  8751. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  8752. + *
  8753. + * This program is free software; you can redistribute it and/or modify
  8754. + * it under the terms of the GNU General Public License version 2 as
  8755. + * published by the Free Software Foundation.
  8756. + */
  8757. +
  8758. +#ifdef CONFIG_DECT_DEBUG
  8759. +#define DEBUG
  8760. +#endif
  8761. +
  8762. +#include <linux/kernel.h>
  8763. +#include <linux/init.h>
  8764. +#include <linux/list.h>
  8765. +#include <linux/skbuff.h>
  8766. +#include <linux/net.h>
  8767. +#include <linux/dect.h>
  8768. +#include <net/dect/dect.h>
  8769. +#include <net/dect/mac_csf.h>
  8770. +#include <net/dect/mac_ccf.h>
  8771. +#include <net/dect/ccp.h>
  8772. +#include <linux/tipc.h>
  8773. +
  8774. +static struct sk_buff *dect_ccp_msg_alloc(size_t size)
  8775. +{
  8776. + struct sk_buff *skb;
  8777. +
  8778. + size += sizeof(struct dect_ccp_msg_hdr) + 2 * LL_MAX_HEADER;
  8779. + skb = alloc_skb(size, GFP_ATOMIC);
  8780. + if (skb == NULL)
  8781. + return NULL;
  8782. + skb_reserve(skb, size);
  8783. + return skb;
  8784. +}
  8785. +
  8786. +static void dect_ccp_build_msg(struct sk_buff *skb,
  8787. + enum dect_ccp_primitives prim)
  8788. +{
  8789. + struct dect_ccp_msg_hdr *h;
  8790. +
  8791. + h = (struct dect_ccp_msg_hdr *)skb_push(skb, sizeof(*h));
  8792. + h->primitive = prim;
  8793. +}
  8794. +
  8795. +static int dect_ccp_send_to_cell(const struct dect_cell_handle *ch,
  8796. + struct sk_buff *skb,
  8797. + enum dect_ccp_primitives prim)
  8798. +{
  8799. + int err;
  8800. +
  8801. + dect_ccp_build_msg(skb, prim);
  8802. + err = tipc_send_buf(ch->portref, skb, skb->len);
  8803. + if (err < 0 && net_ratelimit())
  8804. + printk("Failed to send DECT CCP message\n");
  8805. + return err;
  8806. +}
  8807. +
  8808. +static int dect_ccp_send_to_cluster(const struct dect_cluster_handle *clh,
  8809. + struct sk_buff *skb,
  8810. + enum dect_ccp_primitives prim)
  8811. +{
  8812. + int err;
  8813. +
  8814. + dect_ccp_build_msg(skb, prim);
  8815. + err = tipc_send_buf(clh->portref, skb, skb->len);
  8816. + if (err < 0 && net_ratelimit())
  8817. + printk("Failed to send DECT CCP message\n");
  8818. + return err;
  8819. +}
  8820. +
  8821. +static void dect_ccp_build_tbc_msg(struct sk_buff *skb, const struct dect_tbc_id *id,
  8822. + u8 data)
  8823. +{
  8824. + struct dect_ccp_tbc_msg *msg;
  8825. +
  8826. + msg = (struct dect_ccp_tbc_msg *)__skb_push(skb, sizeof(*msg));
  8827. + msg->tbei = cpu_to_be32(id->tbei);
  8828. + msg->pmid = cpu_to_be32(dect_build_pmid(&id->pmid));
  8829. + msg->ari = cpu_to_be64(dect_build_ari(&id->ari));
  8830. + msg->ecn = id->ecn;
  8831. + msg->data = data;
  8832. +}
  8833. +
  8834. +static bool dect_ccp_parse_tbc_msg(struct dect_tbc_id *id, u8 *data,
  8835. + struct sk_buff *skb)
  8836. +{
  8837. + struct dect_ccp_tbc_msg *msg;
  8838. +
  8839. + if (!pskb_may_pull(skb, sizeof(*msg)))
  8840. + return false;
  8841. + msg = (struct dect_ccp_tbc_msg *)skb->data;
  8842. + __skb_pull(skb, sizeof(*msg));
  8843. +
  8844. + id->tbei = be32_to_cpu(msg->tbei);
  8845. + dect_parse_pmid(&id->pmid, be32_to_cpu(msg->pmid));
  8846. + if (!dect_parse_ari(&id->ari, be64_to_cpu(msg->ari)))
  8847. + return false;
  8848. + id->ecn = msg->ecn;
  8849. + if (data != NULL)
  8850. + *data = msg->data;
  8851. + return true;
  8852. +}
  8853. +
  8854. +static void dect_ccp_build_sysinfo(struct sk_buff *skb,
  8855. + const struct dect_ari *pari, u8 rpn,
  8856. + const struct dect_si *si)
  8857. +{
  8858. + struct dect_ccp_sysinfo_msg *msg;
  8859. + unsigned int i;
  8860. +
  8861. + msg = (struct dect_ccp_sysinfo_msg *)__skb_push(skb, sizeof(*msg));
  8862. + msg->pari = cpu_to_be64(dect_build_ari(pari));
  8863. + for (i = 0; i < si->num_saris; i++)
  8864. + msg->sari[i] = cpu_to_be64(dect_build_ari(&si->sari[i].ari));
  8865. + msg->num_saris = i;
  8866. + msg->fpc = cpu_to_be64(si->fpc.fpc);
  8867. + msg->hlc = cpu_to_be64(si->fpc.hlc);
  8868. + msg->mfn = cpu_to_be32(si->mfn.num);
  8869. + msg->rpn = rpn;
  8870. +}
  8871. +
  8872. +static bool dect_ccp_parse_sysinfo(struct dect_ari *pari, u8 *rpn,
  8873. + struct dect_si *si, struct sk_buff *skb)
  8874. +{
  8875. + struct dect_ccp_sysinfo_msg *msg;
  8876. + unsigned int i;
  8877. +
  8878. + if (!pskb_may_pull(skb, sizeof(*msg)))
  8879. + return false;
  8880. + msg = (struct dect_ccp_sysinfo_msg *)skb->data;
  8881. + __skb_pull(skb, sizeof(*msg));
  8882. +
  8883. + if (!dect_parse_ari(pari, be64_to_cpu(msg->pari)))
  8884. + return false;
  8885. + *rpn = msg->rpn;
  8886. +
  8887. + if (msg->num_saris > ARRAY_SIZE(si->sari))
  8888. + return false;
  8889. + for (i = 0; i < msg->num_saris; i++) {
  8890. + if (!dect_parse_ari(&si->sari[i].ari,
  8891. + be64_to_cpu(msg->sari[i])))
  8892. + return false;
  8893. + }
  8894. + si->fpc.fpc = be64_to_cpu(msg->fpc);
  8895. + si->fpc.hlc = be64_to_cpu(msg->hlc);
  8896. + si->mfn.num = be32_to_cpu(msg->mfn);
  8897. + return true;
  8898. +}
  8899. +
  8900. +static int dect_ccp_send_set_mode(const struct dect_cell_handle *ch,
  8901. + enum dect_cluster_modes mode)
  8902. +{
  8903. + struct dect_ccp_mode_msg *msg;
  8904. + struct sk_buff *skb;
  8905. +
  8906. + skb = dect_ccp_msg_alloc(sizeof(*msg));
  8907. + if (skb == NULL)
  8908. + return -ENOMEM;
  8909. + msg = (struct dect_ccp_mode_msg *)__skb_push(skb, sizeof(*msg));
  8910. + msg->mode = mode;
  8911. +
  8912. + return dect_ccp_send_to_cell(ch, skb, DECT_CCP_SET_MODE);
  8913. +}
  8914. +
  8915. +static void dect_ccp_parse_set_mode(const struct dect_cell_handle *ch,
  8916. + struct sk_buff *skb)
  8917. +{
  8918. + struct dect_ccp_mode_msg *msg;
  8919. +
  8920. + if (!pskb_may_pull(skb, sizeof(*msg)))
  8921. + return;
  8922. + msg = (struct dect_ccp_mode_msg *)skb->data;
  8923. +
  8924. + ch->ops->set_mode(ch, msg->mode);
  8925. +}
  8926. +
  8927. +static int dect_ccp_send_scan(const struct dect_cell_handle *ch,
  8928. + const struct dect_llme_req *lreq,
  8929. + const struct dect_ari *ari,
  8930. + const struct dect_ari *ari_mask)
  8931. +{
  8932. + struct dect_ccp_scan_msg *msg;
  8933. + struct sk_buff *skb;
  8934. +
  8935. + skb = dect_ccp_msg_alloc(sizeof(*msg));
  8936. + if (skb == NULL)
  8937. + return -ENOMEM;
  8938. + msg = (struct dect_ccp_scan_msg *)__skb_push(skb, sizeof(*msg));
  8939. + msg->ari = cpu_to_be64(dect_build_ari(ari));
  8940. + msg->ari_mask = cpu_to_be64(dect_build_ari(ari_mask));
  8941. +
  8942. + return dect_ccp_send_to_cell(ch, skb, DECT_CCP_SCAN);
  8943. +}
  8944. +
  8945. +static void dect_ccp_parse_scan(const struct dect_cell_handle *ch,
  8946. + struct sk_buff *skb)
  8947. +{
  8948. + struct dect_ccp_scan_msg *msg;
  8949. + struct dect_ari ari, ari_mask;
  8950. +
  8951. + if (!pskb_may_pull(skb, sizeof(*msg)))
  8952. + return;
  8953. + msg = (struct dect_ccp_scan_msg *)skb->data;
  8954. +
  8955. + if (!dect_parse_ari(&ari, be64_to_cpu(msg->ari)))
  8956. + return;
  8957. + if (!dect_parse_ari(&ari_mask, be64_to_cpu(msg->ari_mask)))
  8958. + return;
  8959. + ch->ops->scan(ch, NULL, &ari, &ari_mask);
  8960. +}
  8961. +
  8962. +static int dect_ccp_send_preload(const struct dect_cell_handle *ch,
  8963. + const struct dect_ari *pari, u8 rpn,
  8964. + const struct dect_si *si)
  8965. +{
  8966. + struct sk_buff *skb;
  8967. +
  8968. + skb = dect_ccp_msg_alloc(sizeof(struct dect_ccp_sysinfo_msg));
  8969. + if (skb == NULL)
  8970. + return -ENOMEM;
  8971. + dect_ccp_build_sysinfo(skb, pari, rpn, si);
  8972. +
  8973. + return dect_ccp_send_to_cell(ch, skb, DECT_CCP_PRELOAD);
  8974. +}
  8975. +
  8976. +static void dect_ccp_parse_preload(const struct dect_cell_handle *ch,
  8977. + struct sk_buff *skb)
  8978. +{
  8979. + struct dect_ari pari;
  8980. + struct dect_si si;
  8981. + u8 rpn;
  8982. +
  8983. + if (!dect_ccp_parse_sysinfo(&pari, &rpn, &si, skb))
  8984. + return;
  8985. + ch->ops->preload(ch, &pari, rpn, &si);
  8986. +}
  8987. +
  8988. +static int dect_ccp_send_enable(const struct dect_cell_handle *ch)
  8989. +{
  8990. + struct sk_buff *skb;
  8991. +
  8992. + skb = dect_ccp_msg_alloc(0);
  8993. + if (skb == NULL)
  8994. + return -ENOMEM;
  8995. + return dect_ccp_send_to_cell(ch, skb, DECT_CCP_ENABLE);
  8996. +}
  8997. +
  8998. +static void dect_ccp_parse_enable(const struct dect_cell_handle *ch,
  8999. + struct sk_buff *skb)
  9000. +{
  9001. + ch->ops->enable(ch);
  9002. +}
  9003. +
  9004. +static void dect_ccp_send_page_req(const struct dect_cell_handle *ch,
  9005. + struct sk_buff *skb)
  9006. +{
  9007. + struct dect_ccp_page_msg *msg;
  9008. +
  9009. + msg = (struct dect_ccp_page_msg *)__skb_push(skb, sizeof(*msg));
  9010. + msg->fast_page = DECT_BMC_CB(skb)->fast_page;
  9011. + msg->long_page = DECT_BMC_CB(skb)->long_page;
  9012. +
  9013. + dect_ccp_send_to_cell(ch, skb, DECT_CCP_PAGE_REQ);
  9014. +}
  9015. +
  9016. +static void dect_ccp_parse_page_req(const struct dect_cell_handle *ch,
  9017. + struct sk_buff *skb)
  9018. +{
  9019. + struct dect_ccp_page_msg *msg;
  9020. +
  9021. + if (!pskb_may_pull(skb, sizeof(*msg)))
  9022. + return;
  9023. + msg = (struct dect_ccp_page_msg *)skb->data;
  9024. + __pskb_pull(skb, sizeof(*msg));
  9025. +
  9026. + DECT_BMC_CB(skb)->fast_page = msg->fast_page;
  9027. + DECT_BMC_CB(skb)->long_page = msg->long_page;
  9028. +
  9029. + ch->ops->page_req(ch, skb);
  9030. +}
  9031. +
  9032. +static int dect_ccp_send_tbc_establish_req(const struct dect_cell_handle *ch,
  9033. + const struct dect_tbc_id *id,
  9034. + const struct dect_channel_desc *chd,
  9035. + enum dect_mac_service_types service,
  9036. + bool handover)
  9037. +{
  9038. + struct sk_buff *skb;
  9039. +
  9040. + skb = dect_ccp_msg_alloc(sizeof(struct dect_ccp_tbc_msg));
  9041. + if (skb == NULL)
  9042. + return -ENOMEM;
  9043. + dect_ccp_build_tbc_msg(skb, id, 0);
  9044. + return dect_ccp_send_to_cell(ch, skb, DECT_CCP_TBC_ESTABLISH_REQ);
  9045. +}
  9046. +
  9047. +static void dect_ccp_parse_tbc_establish_req(const struct dect_cell_handle *ch,
  9048. + struct sk_buff *skb)
  9049. +{
  9050. + struct dect_tbc_id id;
  9051. +
  9052. + if (!dect_ccp_parse_tbc_msg(&id, NULL, skb))
  9053. + return;
  9054. + ch->ops->tbc_establish_req(ch, &id, NULL, DECT_SERVICE_IN_MIN_DELAY, false);
  9055. +}
  9056. +
  9057. +static void dect_ccp_send_tbc_dis_req(const struct dect_cell_handle *ch,
  9058. + const struct dect_tbc_id *id,
  9059. + enum dect_release_reasons reason)
  9060. +{
  9061. + struct sk_buff *skb;
  9062. +
  9063. + skb = dect_ccp_msg_alloc(sizeof(struct dect_ccp_tbc_msg));
  9064. + if (skb == NULL)
  9065. + return;
  9066. + dect_ccp_build_tbc_msg(skb, id, reason);
  9067. + dect_ccp_send_to_cell(ch, skb, DECT_CCP_TBC_DIS_REQ);
  9068. +}
  9069. +
  9070. +static void dect_ccp_parse_tbc_dis_req(const struct dect_cell_handle *ch,
  9071. + struct sk_buff *skb)
  9072. +{
  9073. + struct dect_tbc_id id;
  9074. + u8 reason;
  9075. +
  9076. + if (!dect_ccp_parse_tbc_msg(&id, &reason, skb))
  9077. + return;
  9078. + ch->ops->tbc_dis_req(ch, &id, reason);
  9079. +}
  9080. +
  9081. +static int dect_ccp_send_tbc_establish_res(const struct dect_cell_handle *ch,
  9082. + const struct dect_tbc_id *id)
  9083. +{
  9084. + struct sk_buff *skb;
  9085. +
  9086. + skb = dect_ccp_msg_alloc(sizeof(struct dect_ccp_tbc_msg));
  9087. + if (skb == NULL)
  9088. + return -ENOMEM;
  9089. + dect_ccp_build_tbc_msg(skb, id, 0);
  9090. + return dect_ccp_send_to_cell(ch, skb, DECT_CCP_TBC_ESTABLISH_RES);
  9091. +}
  9092. +
  9093. +static void dect_ccp_parse_tbc_establish_res(const struct dect_cell_handle *ch,
  9094. + struct sk_buff *skb)
  9095. +{
  9096. + struct dect_tbc_id id;
  9097. +
  9098. + if (!dect_ccp_parse_tbc_msg(&id, NULL, skb))
  9099. + return;
  9100. + ch->ops->tbc_establish_res(ch, &id);
  9101. +}
  9102. +
  9103. +static void dect_ccp_send_tbc_data_req(const struct dect_cell_handle *ch,
  9104. + const struct dect_tbc_id *id,
  9105. + enum dect_data_channels chan,
  9106. + struct sk_buff *skb)
  9107. +{
  9108. + dect_ccp_build_tbc_msg(skb, id, chan);
  9109. + dect_ccp_send_to_cell(ch, skb, DECT_CCP_TBC_DATA_REQ);
  9110. +}
  9111. +
  9112. +static int dect_ccp_send_tbc_enc_key_req(const struct dect_cell_handle *ch,
  9113. + const struct dect_tbc_id *id, u64 ck)
  9114. +{
  9115. + struct dect_ccp_enc_key_msg *msg;
  9116. + struct sk_buff *skb;
  9117. +
  9118. + skb = dect_ccp_msg_alloc(sizeof(struct dect_ccp_tbc_msg) + sizeof(*msg));
  9119. + if (skb == NULL)
  9120. + return -ENOMEM;
  9121. +
  9122. + dect_ccp_build_tbc_msg(skb, id, 0);
  9123. + msg = (struct dect_ccp_enc_key_msg *)skb_tail_pointer(skb);
  9124. + msg->key = cpu_to_be64(ck);
  9125. +
  9126. + return dect_ccp_send_to_cell(ch, skb, DECT_CCP_TBC_ENC_KEY_REQ);
  9127. +}
  9128. +
  9129. +static void dect_ccp_parse_tbc_enc_key_req(const struct dect_cell_handle *ch,
  9130. + struct sk_buff *skb)
  9131. +{
  9132. + const struct dect_ccp_enc_key_msg *msg;
  9133. + struct dect_tbc_id id;
  9134. + u64 ck;
  9135. +
  9136. + if (!dect_ccp_parse_tbc_msg(&id, NULL, skb))
  9137. + return;
  9138. +
  9139. + if (!pskb_may_pull(skb, sizeof(*msg)))
  9140. + return;
  9141. + msg = (struct dect_ccp_enc_key_msg *)skb->data;
  9142. + ck = be64_to_cpu(msg->key);
  9143. +
  9144. + ch->ops->tbc_enc_key_req(ch, &id, ck);
  9145. +}
  9146. +
  9147. +static int dect_ccp_send_tbc_enc_eks_req(const struct dect_cell_handle *ch,
  9148. + const struct dect_tbc_id *id,
  9149. + enum dect_cipher_states status)
  9150. +{
  9151. + struct sk_buff *skb;
  9152. +
  9153. + skb = dect_ccp_msg_alloc(sizeof(struct dect_ccp_tbc_msg));
  9154. + if (skb == NULL)
  9155. + return -ENOMEM;
  9156. + dect_ccp_build_tbc_msg(skb, id, status);
  9157. + return dect_ccp_send_to_cell(ch, skb, DECT_CCP_TBC_ENC_EKS_REQ);
  9158. +}
  9159. +
  9160. +static void dect_ccp_parse_tbc_enc_eks_req(const struct dect_cell_handle *ch,
  9161. + struct sk_buff *skb)
  9162. +{
  9163. + struct dect_tbc_id id;
  9164. + u8 status;
  9165. +
  9166. + if (!dect_ccp_parse_tbc_msg(&id, &status, skb))
  9167. + return;
  9168. +
  9169. + switch (status) {
  9170. + case DECT_CIPHER_DISABLED:
  9171. + case DECT_CIPHER_ENABLED:
  9172. + break;
  9173. + default:
  9174. + return;
  9175. + }
  9176. +
  9177. + ch->ops->tbc_enc_eks_req(ch, &id, status);
  9178. +}
  9179. +
  9180. +static void dect_ccp_send_scan_report(const struct dect_cluster_handle *clh,
  9181. + const struct dect_scan_result *res)
  9182. +{
  9183. +}
  9184. +
  9185. +static void dect_ccp_send_mac_info_ind(const struct dect_cluster_handle *clh,
  9186. + const struct dect_idi *idi,
  9187. + const struct dect_si *si)
  9188. +{
  9189. + struct sk_buff *skb;
  9190. +
  9191. + skb = dect_ccp_msg_alloc(sizeof(struct dect_ccp_sysinfo_msg));
  9192. + if (skb == NULL)
  9193. + return;
  9194. +
  9195. + dect_ccp_build_sysinfo(skb, &idi->pari, idi->rpn, si);
  9196. + dect_ccp_send_to_cluster(clh, skb, DECT_CCP_MAC_INFO_IND);
  9197. +}
  9198. +
  9199. +static void dect_ccp_parse_mac_info_ind(const struct dect_cell_handle *ch,
  9200. + struct sk_buff *skb)
  9201. +{
  9202. + const struct dect_cluster_handle *clh = ch->clh;
  9203. + struct dect_idi idi;
  9204. + struct dect_si si;
  9205. +
  9206. + if (!dect_ccp_parse_sysinfo(&idi.pari, &idi.rpn, &si, skb))
  9207. + return;
  9208. + idi.e = si.num_saris ? true : false;
  9209. +
  9210. + clh->ops->mac_info_ind(clh, &idi, &si);
  9211. +}
  9212. +
  9213. +static int dect_ccp_send_tbc_establish_ind(const struct dect_cluster_handle *clh,
  9214. + const struct dect_cell_handle *ch,
  9215. + const struct dect_tbc_id *id,
  9216. + enum dect_mac_service_types service,
  9217. + bool handover)
  9218. +{
  9219. + struct sk_buff *skb;
  9220. +
  9221. + skb = dect_ccp_msg_alloc(sizeof(struct dect_ccp_tbc_msg));
  9222. + if (skb == NULL)
  9223. + return -ENOMEM;
  9224. + dect_ccp_build_tbc_msg(skb, id, 0);
  9225. +
  9226. + return dect_ccp_send_to_cluster(clh, skb, DECT_CCP_TBC_ESTABLISH_IND);
  9227. +}
  9228. +
  9229. +static void dect_ccp_parse_tbc_establish_ind(const struct dect_cell_handle *ch,
  9230. + struct sk_buff *skb)
  9231. +{
  9232. + const struct dect_cluster_handle *clh = ch->clh;
  9233. + struct dect_tbc_id id;
  9234. +
  9235. + if (!dect_ccp_parse_tbc_msg(&id, NULL, skb))
  9236. + return;
  9237. + clh->ops->tbc_establish_ind(clh, ch, &id, DECT_SERVICE_IN_MIN_DELAY, false);
  9238. +}
  9239. +
  9240. +static int dect_ccp_send_tbc_establish_cfm(const struct dect_cluster_handle *clh,
  9241. + const struct dect_tbc_id *id,
  9242. + bool success, u8 rx_slot)
  9243. +{
  9244. + struct sk_buff *skb;
  9245. +
  9246. + skb = dect_ccp_msg_alloc(sizeof(struct dect_ccp_tbc_msg));
  9247. + if (skb == NULL)
  9248. + return -ENOMEM;
  9249. + dect_ccp_build_tbc_msg(skb, id, 0);
  9250. +
  9251. + return dect_ccp_send_to_cluster(clh, skb, DECT_CCP_TBC_ESTABLISH_CFM);
  9252. +}
  9253. +
  9254. +static void dect_ccp_parse_tbc_establish_cfm(const struct dect_cell_handle *ch,
  9255. + struct sk_buff *skb)
  9256. +{
  9257. + const struct dect_cluster_handle *clh = ch->clh;
  9258. + struct dect_tbc_id id;
  9259. +
  9260. + if (!dect_ccp_parse_tbc_msg(&id, NULL, skb))
  9261. + return;
  9262. + clh->ops->tbc_establish_cfm(clh, &id, true, 0);
  9263. +}
  9264. +
  9265. +static int dect_ccp_send_tbc_event_ind(const struct dect_cluster_handle *clh,
  9266. + const struct dect_tbc_id *id,
  9267. + enum dect_tbc_event event)
  9268. +{
  9269. + struct sk_buff *skb;
  9270. +
  9271. + skb = dect_ccp_msg_alloc(sizeof(struct dect_ccp_tbc_msg));
  9272. + if (skb == NULL)
  9273. + return -ENOMEM;
  9274. + dect_ccp_build_tbc_msg(skb, id, event);
  9275. +
  9276. + return dect_ccp_send_to_cluster(clh, skb, DECT_CCP_TBC_EVENT_IND);
  9277. +}
  9278. +
  9279. +static void dect_ccp_parse_tbc_event_ind(const struct dect_cell_handle *ch,
  9280. + struct sk_buff *skb)
  9281. +{
  9282. + const struct dect_cluster_handle *clh = ch->clh;
  9283. + struct dect_tbc_id id;
  9284. + u8 event;
  9285. +
  9286. + if (!dect_ccp_parse_tbc_msg(&id, &event, skb))
  9287. + return;
  9288. + clh->ops->tbc_event_ind(clh, &id, event);
  9289. +}
  9290. +
  9291. +static void dect_ccp_send_tbc_data_ind(const struct dect_cluster_handle *clh,
  9292. + const struct dect_tbc_id *id,
  9293. + enum dect_data_channels chan,
  9294. + struct sk_buff *skb)
  9295. +{
  9296. + dect_ccp_build_tbc_msg(skb, id, chan);
  9297. + dect_ccp_send_to_cluster(clh, skb, DECT_CCP_TBC_DATA_IND);
  9298. +}
  9299. +
  9300. +static void dect_ccp_parse_tbc_data_ind(const struct dect_cell_handle *ch,
  9301. + struct sk_buff *skb)
  9302. +{
  9303. + const struct dect_cluster_handle *clh = ch->clh;
  9304. + struct dect_tbc_id id;
  9305. + u8 chan;
  9306. +
  9307. + if (!dect_ccp_parse_tbc_msg(&id, &chan, skb))
  9308. + return;
  9309. + clh->ops->tbc_data_ind(clh, &id, chan, skb);
  9310. +}
  9311. +
  9312. +static void dect_ccp_send_tbc_dis_ind(const struct dect_cluster_handle *clh,
  9313. + const struct dect_tbc_id *id,
  9314. + enum dect_release_reasons reason)
  9315. +{
  9316. + struct sk_buff *skb;
  9317. +
  9318. + skb = dect_ccp_msg_alloc(sizeof(struct dect_ccp_tbc_msg));
  9319. + if (skb == NULL)
  9320. + return;// -ENOMEM;
  9321. + dect_ccp_build_tbc_msg(skb, id, reason);
  9322. +
  9323. + dect_ccp_send_to_cluster(clh, skb, DECT_CCP_TBC_DIS_IND);
  9324. +}
  9325. +
  9326. +static void dect_ccp_parse_tbc_dis_ind(const struct dect_cell_handle *ch,
  9327. + struct sk_buff *skb)
  9328. +{
  9329. + const struct dect_cluster_handle *clh = ch->clh;
  9330. + struct dect_tbc_id id;
  9331. + u8 reason;
  9332. +
  9333. + if (!dect_ccp_parse_tbc_msg(&id, &reason, skb))
  9334. + return;
  9335. + clh->ops->tbc_dis_ind(clh, &id, reason);
  9336. +}
  9337. +
  9338. +static void dect_ccp_rcv_cell_msg(void *handle, u32 portref,
  9339. + struct sk_buff **pskb,
  9340. + const u8 *data, u32 size)
  9341. +{
  9342. + struct dect_cell_handle *ch = handle;
  9343. + struct dect_ccp_msg_hdr *h;
  9344. + struct sk_buff *skb = *pskb;
  9345. +
  9346. + if (!pskb_may_pull(skb, sizeof(*h)))
  9347. + return;
  9348. + h = (struct dect_ccp_msg_hdr *)skb->data;
  9349. + __skb_pull(skb, sizeof(*h));
  9350. +
  9351. + switch (h->primitive) {
  9352. + case DECT_CCP_MAC_INFO_IND:
  9353. + return dect_ccp_parse_mac_info_ind(ch, skb);
  9354. + case DECT_CCP_TBC_ESTABLISH_IND:
  9355. + return dect_ccp_parse_tbc_establish_ind(ch, skb);
  9356. + case DECT_CCP_TBC_ESTABLISH_CFM:
  9357. + return dect_ccp_parse_tbc_establish_cfm(ch, skb);
  9358. + case DECT_CCP_TBC_EVENT_IND:
  9359. + return dect_ccp_parse_tbc_event_ind(ch, skb);
  9360. + case DECT_CCP_TBC_DATA_IND:
  9361. + return dect_ccp_parse_tbc_data_ind(ch, skb);
  9362. + case DECT_CCP_TBC_DIS_IND:
  9363. + return dect_ccp_parse_tbc_dis_ind(ch, skb);
  9364. + }
  9365. +}
  9366. +
  9367. +static void dect_ccp_cl_disconnect(void *handle, u32 portref,
  9368. + struct sk_buff **pskb,
  9369. + const u8 *data, u32 size, int reason)
  9370. +{
  9371. + struct dect_cell_handle *ch = handle;
  9372. + struct dect_cluster_handle *clh = ch->clh;
  9373. +
  9374. + pr_debug("cell disconnected\n");
  9375. + clh->ops->unbind(clh, ch);
  9376. + kfree(ch);
  9377. +}
  9378. +
  9379. +static const struct dect_csf_ops dect_ccp_csf_ops = {
  9380. + .set_mode = dect_ccp_send_set_mode,
  9381. + .scan = dect_ccp_send_scan,
  9382. + .enable = dect_ccp_send_enable,
  9383. + .preload = dect_ccp_send_preload,
  9384. + .page_req = dect_ccp_send_page_req,
  9385. + .tbc_establish_req = dect_ccp_send_tbc_establish_req,
  9386. + .tbc_establish_res = dect_ccp_send_tbc_establish_res,
  9387. + .tbc_dis_req = dect_ccp_send_tbc_dis_req,
  9388. + .tbc_enc_key_req = dect_ccp_send_tbc_enc_key_req,
  9389. + .tbc_enc_eks_req = dect_ccp_send_tbc_enc_eks_req,
  9390. + .tbc_data_req = dect_ccp_send_tbc_data_req,
  9391. +};
  9392. +
  9393. +static void dect_ccp_cl_named_msg(void *handle, u32 portref,
  9394. + struct sk_buff **pskb,
  9395. + const u8 *data, u32 size,
  9396. + u32 importance,
  9397. + const struct tipc_portid *source,
  9398. + const struct tipc_name_seq *dest)
  9399. +{
  9400. + struct dect_cluster *cl = handle;
  9401. + struct dect_cluster_handle *clh = &cl->handle;
  9402. + struct dect_cell_handle *ch;
  9403. + struct iovec ack = { NULL, 0};
  9404. + int err;
  9405. +
  9406. + ch = kzalloc(sizeof(*ch), GFP_ATOMIC);
  9407. + if (ch == NULL)
  9408. + goto err1;
  9409. + ch->ops = &dect_ccp_csf_ops;
  9410. +
  9411. + err = tipc_createport(cl->tipc_id, ch, TIPC_HIGH_IMPORTANCE,
  9412. + NULL, NULL, dect_ccp_cl_disconnect,
  9413. + NULL, NULL, dect_ccp_rcv_cell_msg, NULL,
  9414. + &ch->portref);
  9415. + if (err < 0)
  9416. + goto err2;
  9417. +
  9418. + err = tipc_connect2port(ch->portref, source);
  9419. + if (err < 0)
  9420. + goto err3;
  9421. +
  9422. + err = tipc_send(ch->portref, 1, &ack);
  9423. + if (err < 0)
  9424. + goto err3;
  9425. +
  9426. + err = clh->ops->bind(clh, ch);
  9427. + if (err < 0)
  9428. + goto err4;
  9429. + return;
  9430. +
  9431. +err4:
  9432. + tipc_disconnect(ch->portref);
  9433. +err3:
  9434. + tipc_deleteport(ch->portref);
  9435. +err2:
  9436. + kfree(ch);
  9437. +err1:
  9438. + return;
  9439. +}
  9440. +
  9441. +/**
  9442. + * dect_ccp_cluster_init - Initialize a cluster control CCP instance
  9443. + *
  9444. + * @cl: DECT cluster
  9445. + */
  9446. +int dect_ccp_cluster_init(struct dect_cluster *cl)
  9447. +{
  9448. + struct tipc_name_seq seq;
  9449. + int err;
  9450. +
  9451. + err = tipc_attach(&cl->tipc_id, NULL, NULL);
  9452. + if (err < 0)
  9453. + goto err1;
  9454. +
  9455. + err = tipc_createport(cl->tipc_id, cl, TIPC_HIGH_IMPORTANCE,
  9456. + NULL, NULL, NULL, NULL, dect_ccp_cl_named_msg,
  9457. + NULL, NULL, &cl->tipc_portref);
  9458. + if (err < 0)
  9459. + goto err2;
  9460. +
  9461. + seq.type = DECT_CCP_TIPC_TYPE;
  9462. + seq.lower = DECT_CCP_CLUSTER_PORT_BASE + cl->index;
  9463. + seq.upper = DECT_CCP_CLUSTER_PORT_BASE + cl->index;
  9464. + err = tipc_publish(cl->tipc_portref, TIPC_CLUSTER_SCOPE, &seq);
  9465. + if (err < 0)
  9466. + goto err3;
  9467. + return 0;
  9468. +
  9469. +err3:
  9470. + tipc_deleteport(cl->tipc_portref);
  9471. +err2:
  9472. + tipc_detach(cl->tipc_id);
  9473. +err1:
  9474. + return err;
  9475. +}
  9476. +
  9477. +void dect_ccp_cluster_shutdown(struct dect_cluster *cl)
  9478. +{
  9479. + tipc_detach(cl->tipc_id);
  9480. +}
  9481. +
  9482. +static void dect_ccp_rcv_cluster_msg(void *handle, u32 portref,
  9483. + struct sk_buff **pskb,
  9484. + const u8 *data, u32 size)
  9485. +{
  9486. + struct sk_buff *skb = *pskb;
  9487. + struct dect_cell_handle *ch = handle;
  9488. + struct dect_ccp_msg_hdr *h;
  9489. +
  9490. + if (!pskb_may_pull(skb, sizeof(*h)))
  9491. + return;
  9492. + h = (struct dect_ccp_msg_hdr *)skb->data;
  9493. + __skb_pull(skb, sizeof(*h));
  9494. +
  9495. + switch (h->primitive) {
  9496. + case DECT_CCP_SET_MODE:
  9497. + return dect_ccp_parse_set_mode(ch, skb);
  9498. + case DECT_CCP_SCAN:
  9499. + return dect_ccp_parse_scan(ch, skb);
  9500. + case DECT_CCP_ENABLE:
  9501. + return dect_ccp_parse_enable(ch, skb);
  9502. + case DECT_CCP_PRELOAD:
  9503. + return dect_ccp_parse_preload(ch, skb);
  9504. + case DECT_CCP_PAGE_REQ:
  9505. + return dect_ccp_parse_page_req(ch, skb);
  9506. + case DECT_CCP_TBC_ESTABLISH_REQ:
  9507. + return dect_ccp_parse_tbc_establish_req(ch, skb);
  9508. + case DECT_CCP_TBC_ESTABLISH_RES:
  9509. + return dect_ccp_parse_tbc_establish_res(ch, skb);
  9510. + case DECT_CCP_TBC_DIS_REQ:
  9511. + return dect_ccp_parse_tbc_dis_req(ch, skb);
  9512. + case DECT_CCP_TBC_ENC_KEY_REQ:
  9513. + return dect_ccp_parse_tbc_enc_key_req(ch, skb);
  9514. + case DECT_CCP_TBC_ENC_EKS_REQ:
  9515. + return dect_ccp_parse_tbc_enc_eks_req(ch, skb);
  9516. + }
  9517. +}
  9518. +
  9519. +static void dect_ccp_cluster_disconnect(void *handle, u32 portref,
  9520. + struct sk_buff **pskb,
  9521. + const u8 *data, u32 size, int reason)
  9522. +{
  9523. + pr_debug("Cluster disconnected\n");
  9524. +#if 0
  9525. + struct dect_cell_handle *clh = handle;
  9526. +
  9527. + clh->ops->unbind(clh);
  9528. +#endif
  9529. +}
  9530. +
  9531. +static void dect_ccp_subscr_rcv(void *handle, u32 portref,
  9532. + struct sk_buff **pskb,
  9533. + const u8 *data, u32 size)
  9534. +{
  9535. + struct dect_cell_handle *ch = handle;
  9536. + struct dect_cluster_handle *clh = ch->clh;
  9537. + struct sk_buff *skb = *pskb;
  9538. + struct tipc_event *ev;
  9539. + struct tipc_name name;
  9540. + int err;
  9541. +
  9542. + if (!pskb_may_pull(skb, sizeof(*ev)))
  9543. + return;
  9544. + ev = (struct tipc_event *)skb->data;
  9545. +
  9546. + if (ev->event != TIPC_PUBLISHED)
  9547. + return;
  9548. +
  9549. + /* Connect to cluster */
  9550. + err = tipc_createport(clh->tipc_id, ch, TIPC_HIGH_IMPORTANCE,
  9551. + NULL, NULL, dect_ccp_cluster_disconnect,
  9552. + NULL, NULL, dect_ccp_rcv_cluster_msg, NULL,
  9553. + &clh->portref);
  9554. + if (err < 0)
  9555. + goto err1;
  9556. +
  9557. + name.type = DECT_CCP_TIPC_TYPE;
  9558. + name.instance = DECT_CCP_CLUSTER_PORT_BASE + clh->index;
  9559. + err = tipc_send2name(clh->portref, &name, 0, 0, NULL);
  9560. + if (err < 0)
  9561. + goto err2;
  9562. + return;
  9563. +
  9564. +err2:
  9565. + tipc_deleteport(clh->portref);
  9566. +err1:
  9567. + return;
  9568. +}
  9569. +
  9570. +/**
  9571. + * dect_ccp_cell_init - Initialize a cell CCP instance
  9572. + *
  9573. + * @cell: DECT cell
  9574. + */
  9575. +static int dect_ccp_bind_cell(struct dect_cluster_handle *clh,
  9576. + struct dect_cell_handle *ch)
  9577. +{
  9578. + struct tipc_subscr subscr;
  9579. + struct iovec iov = { &subscr, sizeof(subscr) };
  9580. + struct tipc_name tname;
  9581. + int err;
  9582. +
  9583. + err = tipc_attach(&clh->tipc_id, NULL, NULL);
  9584. + if (err < 0)
  9585. + goto err1;
  9586. + ch->clh = clh;
  9587. +
  9588. + /* Connect to topology service and subscribe to cluster port */
  9589. + err = tipc_createport(clh->tipc_id, ch, TIPC_CRITICAL_IMPORTANCE,
  9590. + NULL, NULL, NULL, NULL, NULL,
  9591. + dect_ccp_subscr_rcv, NULL, &clh->tportref);
  9592. + if (err < 0)
  9593. + goto err2;
  9594. +
  9595. + subscr.seq.type = DECT_CCP_TIPC_TYPE;
  9596. + subscr.seq.lower = DECT_CCP_CLUSTER_PORT_BASE + clh->index;
  9597. + subscr.seq.upper = DECT_CCP_CLUSTER_PORT_BASE + clh->index;
  9598. + subscr.timeout = TIPC_WAIT_FOREVER;
  9599. + subscr.filter = TIPC_SUB_PORTS;
  9600. + memset(&subscr.usr_handle, 0, sizeof(subscr.usr_handle));
  9601. +
  9602. + tname.type = TIPC_TOP_SRV;
  9603. + tname.instance = TIPC_TOP_SRV;
  9604. +
  9605. + err = tipc_send2name(clh->tportref, &tname, 0, 1, &iov);
  9606. + if (err < 0)
  9607. + goto err3;
  9608. + return 0;
  9609. +
  9610. +err3:
  9611. + tipc_deleteport(clh->tportref);
  9612. +err2:
  9613. + tipc_detach(clh->tipc_id);
  9614. +err1:
  9615. + return err;
  9616. +
  9617. +}
  9618. +
  9619. +static void dect_ccp_unbind_cell(struct dect_cluster_handle *clh,
  9620. + struct dect_cell_handle *ch)
  9621. +{
  9622. + tipc_detach(clh->tipc_id);
  9623. +}
  9624. +
  9625. +static void dect_ccp_send_bmc_page_ind(const struct dect_cluster_handle *clh,
  9626. + struct sk_buff *skb)
  9627. +{
  9628. +}
  9629. +
  9630. +static const struct dect_ccf_ops dect_ccp_ccf_ops = {
  9631. + .bind = dect_ccp_bind_cell,
  9632. + .unbind = dect_ccp_unbind_cell,
  9633. + .scan_report = dect_ccp_send_scan_report,
  9634. + .mac_info_ind = dect_ccp_send_mac_info_ind,
  9635. + .tbc_establish_ind = dect_ccp_send_tbc_establish_ind,
  9636. + .tbc_establish_cfm = dect_ccp_send_tbc_establish_cfm,
  9637. + .tbc_event_ind = dect_ccp_send_tbc_event_ind,
  9638. + .tbc_dis_ind = dect_ccp_send_tbc_dis_ind,
  9639. + .tbc_data_ind = dect_ccp_send_tbc_data_ind,
  9640. + .bmc_page_ind = dect_ccp_send_bmc_page_ind,
  9641. +};
  9642. +
  9643. +struct dect_cluster_handle *dect_ccp_cell_init(struct dect_cell *cell, u8 clindex)
  9644. +{
  9645. + struct dect_cluster_handle *clh;
  9646. +
  9647. + clh = kzalloc(sizeof(*clh), GFP_KERNEL);
  9648. + if (clh == NULL)
  9649. + return ERR_PTR(-ENOMEM);
  9650. + clh->index = clindex;
  9651. + clh->ops = &dect_ccp_ccf_ops;
  9652. + return clh;
  9653. +}
  9654. diff --git a/net/dect/core.c b/net/dect/core.c
  9655. new file mode 100644
  9656. index 0000000..80a7dd8
  9657. --- /dev/null
  9658. +++ b/net/dect/core.c
  9659. @@ -0,0 +1,183 @@
  9660. +/*
  9661. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  9662. + *
  9663. + * This program is free software; you can redistribute it and/or modify
  9664. + * it under the terms of the GNU General Public License version 2 as
  9665. + * published by the Free Software Foundation.
  9666. + */
  9667. +
  9668. +#ifdef CONFIG_DECT_DEBUG
  9669. +#define DEBUG
  9670. +#endif
  9671. +
  9672. +#include <linux/kernel.h>
  9673. +#include <linux/module.h>
  9674. +#include <linux/init.h>
  9675. +#include <linux/mutex.h>
  9676. +#include <linux/list.h>
  9677. +#include <linux/notifier.h>
  9678. +#include <net/dect/dect.h>
  9679. +#include <net/dect/transceiver.h>
  9680. +
  9681. +static DEFINE_MUTEX(dect_cfg_mutex);
  9682. +
  9683. +void dect_lock(void)
  9684. +{
  9685. + mutex_lock(&dect_cfg_mutex);
  9686. +}
  9687. +EXPORT_SYMBOL_GPL(dect_lock);
  9688. +
  9689. +void dect_unlock(void)
  9690. +{
  9691. + mutex_unlock(&dect_cfg_mutex);
  9692. +}
  9693. +EXPORT_SYMBOL_GPL(dect_unlock);
  9694. +
  9695. +/*
  9696. + * MAC layer timers
  9697. + */
  9698. +
  9699. +#if 1
  9700. +#define timer_debug(name, base, fmt, args...) \
  9701. + pr_debug("%s: %s %u.%.2u.%.2u: " fmt, name, \
  9702. + (base)->base == DECT_TIMER_TX ? "TX" : "RX", \
  9703. + base->mfn, base->framenum, base->slot, ## args)
  9704. +#else
  9705. +#define timer_debug(base, fmt, args...)
  9706. +#endif
  9707. +
  9708. +void __dect_run_timers(const char *name, struct dect_timer_base *base)
  9709. +{
  9710. + struct dect_timer *t;
  9711. +
  9712. + while (!list_empty(&base->timers)) {
  9713. + t = list_first_entry(&base->timers, struct dect_timer, list);
  9714. +
  9715. + if (dect_mfn_after(t->mfn, base->mfn) ||
  9716. + (t->mfn == base->mfn && t->frame > base->framenum) ||
  9717. + (t->mfn == base->mfn && t->frame == base->framenum &&
  9718. + t->slot > base->slot))
  9719. + break;
  9720. +
  9721. + timer_debug(name, base, "timer %p: %u.%u.%u\n",
  9722. + t, t->mfn, t->frame, t->slot);
  9723. + list_del_init(&t->list);
  9724. + t->cb.cb(t->obj, t->data);
  9725. + }
  9726. +}
  9727. +EXPORT_SYMBOL_GPL(__dect_run_timers);
  9728. +
  9729. +/**
  9730. + * dect_timer_add - (re)schedule a timer
  9731. + *
  9732. + * Frame numbers are relative to the current time, slot positions are absolute.
  9733. + * A timer scheduled for (1, 2) will expire in slot 2 in the next frame.
  9734. + *
  9735. + * A frame number of zero will expire at the next occurence of the slot, which
  9736. + * can be within the same frame in case the slot is not already in the past, or
  9737. + * in the next frame in case it is.
  9738. + */
  9739. +void __dect_timer_add(const char *name, struct dect_timer_base *base,
  9740. + struct dect_timer *timer, u32 frame, u8 slot)
  9741. +{
  9742. + struct dect_timer *t;
  9743. + u32 mfn;
  9744. +
  9745. + if (frame == 0 && slot < base->slot)
  9746. + frame++;
  9747. + frame += base->framenum;
  9748. + mfn = dect_mfn_add(base->mfn, frame / DECT_FRAMES_PER_MULTIFRAME);
  9749. + frame %= DECT_FRAMES_PER_MULTIFRAME;
  9750. +
  9751. + timer_debug(name, base, "timer %p: schedule for %u.%u.%u\n",
  9752. + timer, mfn, frame, slot);
  9753. + if (!list_empty(&timer->list))
  9754. + list_del(&timer->list);
  9755. + list_for_each_entry(t, &base->timers, list) {
  9756. + if (dect_mfn_after(t->mfn, mfn) ||
  9757. + (t->mfn == mfn && t->frame > frame) ||
  9758. + (t->mfn == mfn && t->frame == frame && t->slot > slot))
  9759. + break;
  9760. + }
  9761. +
  9762. + timer->mfn = mfn;
  9763. + timer->frame = frame;
  9764. + timer->slot = slot;
  9765. + list_add_tail(&timer->list, &t->list);
  9766. +}
  9767. +EXPORT_SYMBOL_GPL(__dect_timer_add);
  9768. +
  9769. +struct sk_buff *skb_append_frag(struct sk_buff *head, struct sk_buff *skb)
  9770. +{
  9771. + struct sk_buff **pprev;
  9772. +
  9773. + if (head == NULL)
  9774. + return skb;
  9775. +
  9776. + pprev = &skb_shinfo(head)->frag_list;
  9777. + while (*pprev != NULL)
  9778. + pprev = &(*pprev)->next;
  9779. + *pprev = skb;
  9780. +
  9781. + head->data_len += skb->len;
  9782. + head->len += skb->len;
  9783. + head->truesize += skb->truesize;
  9784. + return head;
  9785. +}
  9786. +EXPORT_SYMBOL_GPL(skb_append_frag);
  9787. +
  9788. +unsigned int skb_queue_pull(struct sk_buff_head *list, unsigned int len)
  9789. +{
  9790. + unsigned int pulled = 0;
  9791. + unsigned long flags;
  9792. + struct sk_buff *skb;
  9793. +
  9794. + spin_lock_irqsave(&list->lock, flags);
  9795. + while (len > pulled) {
  9796. + skb = skb_peek(list);
  9797. + if (skb == NULL)
  9798. + break;
  9799. + if (skb->len <= len) {
  9800. + __skb_unlink(skb, list);
  9801. + pulled += skb->len;
  9802. + kfree_skb(skb);
  9803. + } else {
  9804. + __skb_pull(skb, len);
  9805. + pulled += len;
  9806. + }
  9807. + }
  9808. + spin_unlock_irqrestore(&list->lock, flags);
  9809. + return pulled;
  9810. +}
  9811. +EXPORT_SYMBOL_GPL(skb_queue_pull);
  9812. +
  9813. +static int __init dect_module_init(void)
  9814. +{
  9815. + int err;
  9816. +
  9817. + err = dect_netlink_module_init();
  9818. + if (err < 0)
  9819. + goto err1;
  9820. + err = dect_af_module_init();
  9821. + if (err < 0)
  9822. + goto err2;
  9823. + return 0;
  9824. +
  9825. +err2:
  9826. + dect_netlink_module_exit();
  9827. +err1:
  9828. + return err;
  9829. +}
  9830. +
  9831. +static void __exit dect_module_exit(void)
  9832. +{
  9833. + dect_af_module_exit();
  9834. + dect_netlink_module_exit();
  9835. +}
  9836. +
  9837. +module_init(dect_module_init);
  9838. +module_exit(dect_module_exit);
  9839. +
  9840. +MODULE_AUTHOR("Patrick McHardy <[email protected]>");
  9841. +MODULE_DESCRIPTION("DECT protocol stack");
  9842. +MODULE_LICENSE("GPL");
  9843. diff --git a/net/dect/dect_netlink.c b/net/dect/dect_netlink.c
  9844. new file mode 100644
  9845. index 0000000..80527fb
  9846. --- /dev/null
  9847. +++ b/net/dect/dect_netlink.c
  9848. @@ -0,0 +1,152 @@
  9849. +/*
  9850. + * DECT netlink control interface
  9851. + *
  9852. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  9853. + *
  9854. + * This program is free software; you can redistribute it and/or modify
  9855. + * it under the terms of the GNU General Public License version 2 as
  9856. + * published by the Free Software Foundation.
  9857. + */
  9858. +
  9859. +#include <linux/kernel.h>
  9860. +#include <linux/module.h>
  9861. +#include <linux/netlink.h>
  9862. +#include <linux/skbuff.h>
  9863. +#include <linux/net.h>
  9864. +#include <linux/dect_netlink.h>
  9865. +#include <linux/dect.h>
  9866. +#include <net/netlink.h>
  9867. +#include <net/sock.h>
  9868. +#include <net/dect/dect.h>
  9869. +#include <net/dect/mac_csf.h>
  9870. +
  9871. +struct sock *dect_nlsk __read_mostly;
  9872. +EXPORT_SYMBOL_GPL(dect_nlsk);
  9873. +
  9874. +LIST_HEAD(dect_cluster_list);
  9875. +EXPORT_SYMBOL_GPL(dect_cluster_list);
  9876. +
  9877. +struct dect_cluster *dect_cluster_get_by_index(int index)
  9878. +{
  9879. + struct dect_cluster *cl;
  9880. +
  9881. + list_for_each_entry(cl, &dect_cluster_list, list) {
  9882. + if (cl->index == index)
  9883. + return cl;
  9884. + }
  9885. + return NULL;
  9886. +}
  9887. +EXPORT_SYMBOL_GPL(dect_cluster_get_by_index);
  9888. +
  9889. +static const struct dect_netlink_handler *dect_dispatch[DECT_NR_MSGTYPES];
  9890. +
  9891. +void dect_netlink_register_handlers(const struct dect_netlink_handler *handler,
  9892. + unsigned int base, unsigned int n)
  9893. +{
  9894. + unsigned int i;
  9895. +
  9896. + dect_lock();
  9897. + base -= DECT_MSG_BASE;
  9898. + for (i = 0; i < n; i++)
  9899. + dect_dispatch[base + i] = handler + i;
  9900. + dect_unlock();
  9901. +}
  9902. +EXPORT_SYMBOL_GPL(dect_netlink_register_handlers);
  9903. +
  9904. +void dect_netlink_unregister_handlers(unsigned int base, unsigned int n)
  9905. +{
  9906. + unsigned int i;
  9907. +
  9908. + dect_lock();
  9909. + base -= DECT_MSG_BASE;
  9910. + for (i = 0; i < n; i++)
  9911. + dect_dispatch[base + i] = NULL;
  9912. + dect_unlock();
  9913. +}
  9914. +EXPORT_SYMBOL_GPL(dect_netlink_unregister_handlers);
  9915. +
  9916. +static int dect_netlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
  9917. +{
  9918. + const struct dect_netlink_handler *link;
  9919. + u16 type;
  9920. + int err;
  9921. +
  9922. + type = nlh->nlmsg_type;
  9923. + if (type > DECT_MSG_MAX)
  9924. + return -EINVAL;
  9925. +
  9926. + link = dect_dispatch[type - DECT_MSG_BASE];
  9927. + if (link == NULL) {
  9928. +#ifdef CONFIG_MODULES
  9929. + dect_unlock();
  9930. + switch (type) {
  9931. + case DECT_NEW_TRANSCEIVER ... DECT_GET_CELL:
  9932. + request_module("dect_csf");
  9933. + break;
  9934. + case DECT_NEW_CLUSTER ... DECT_LLME_MSG:
  9935. + request_module("dect_ccf");
  9936. + break;
  9937. + }
  9938. + dect_lock();
  9939. +
  9940. + link = dect_dispatch[type - DECT_MSG_BASE];
  9941. + if (link == NULL)
  9942. +#endif
  9943. + return -EOPNOTSUPP;
  9944. + }
  9945. +
  9946. + /* dump and get requests don't require privileges */
  9947. + if (link->dump == NULL && !capable(CAP_NET_ADMIN))
  9948. + return -EPERM;
  9949. +
  9950. + if (nlh->nlmsg_flags & NLM_F_DUMP) {
  9951. + struct netlink_dump_control c = {
  9952. + .dump = link->dump,
  9953. + .done = link->done,
  9954. + };
  9955. +
  9956. + if (link->dump == NULL)
  9957. + return -EOPNOTSUPP;
  9958. + return netlink_dump_start(dect_nlsk, skb, nlh, &c);
  9959. + } else {
  9960. + struct nlattr *nla[link->maxtype + 1];
  9961. +
  9962. + err = nlmsg_parse(nlh, sizeof(struct dectmsg), nla,
  9963. + link->maxtype, link->policy);
  9964. + if (err < 0)
  9965. + return err;
  9966. + if (link->doit == NULL)
  9967. + return -EOPNOTSUPP;
  9968. + return link->doit(skb, nlh, (const struct nlattr **)nla);
  9969. + }
  9970. +}
  9971. +
  9972. +static void dect_netlink_rcv(struct sk_buff *skb)
  9973. +{
  9974. + dect_lock();
  9975. + netlink_rcv_skb(skb, dect_netlink_rcv_msg);
  9976. + dect_unlock();
  9977. +}
  9978. +
  9979. +static struct netlink_kernel_cfg dect_netlink_cfg = {
  9980. + .groups = DECTNLGRP_MAX,
  9981. + .input = dect_netlink_rcv,
  9982. +};
  9983. +
  9984. +int __init dect_netlink_module_init(void)
  9985. +{
  9986. + struct sock *sk;
  9987. +
  9988. + sk = netlink_kernel_create(&init_net, NETLINK_DECT, &dect_netlink_cfg);
  9989. + if (sk == NULL)
  9990. + return -ENOMEM;
  9991. + dect_nlsk = sk;
  9992. + return 0;
  9993. +}
  9994. +
  9995. +void dect_netlink_module_exit(void)
  9996. +{
  9997. + netlink_kernel_release(dect_nlsk);
  9998. +}
  9999. +
  10000. +MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_DECT);
  10001. diff --git a/net/dect/dlc.c b/net/dect/dlc.c
  10002. new file mode 100644
  10003. index 0000000..c2d287d
  10004. --- /dev/null
  10005. +++ b/net/dect/dlc.c
  10006. @@ -0,0 +1,282 @@
  10007. +/*
  10008. + * DECT DLC Layer
  10009. + *
  10010. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  10011. + *
  10012. + * This program is free software; you can redistribute it and/or modify
  10013. + * it under the terms of the GNU General Public License version 2 as
  10014. + * published by the Free Software Foundation.
  10015. + */
  10016. +
  10017. +#ifdef CONFIG_DECT_DEBUG
  10018. +#define DEBUG
  10019. +#endif
  10020. +
  10021. +#include <linux/kernel.h>
  10022. +#include <linux/module.h>
  10023. +#include <linux/init.h>
  10024. +#include <linux/list.h>
  10025. +#include <linux/skbuff.h>
  10026. +#include <linux/net.h>
  10027. +#include <linux/dect.h>
  10028. +#include <net/dect/dect.h>
  10029. +
  10030. +#define mc_debug(mc, fmt, args...) \
  10031. + pr_debug("MC (MCEI %u/%s): " fmt, \
  10032. + (mc)->mcei, dect_mc_states[(mc)->state], ## args)
  10033. +
  10034. +static const char * const dect_mc_states[] = {
  10035. + [DECT_MAC_CONN_CLOSED] = "CLOSED",
  10036. + [DECT_MAC_CONN_OPEN_PENDING] = "OPEN_PENDING",
  10037. + [DECT_MAC_CONN_OPEN] = "OPEN",
  10038. +};
  10039. +
  10040. +static struct dect_mac_conn *
  10041. +dect_mac_conn_get_by_mcei(const struct dect_cluster *cl, u32 mcei)
  10042. +{
  10043. + struct dect_mac_conn *mc;
  10044. +
  10045. + list_for_each_entry(mc, &cl->mac_connections, list) {
  10046. + if (mc->mcei == mcei)
  10047. + return mc;
  10048. + }
  10049. + return NULL;
  10050. +}
  10051. +
  10052. +struct dect_mac_conn *
  10053. +dect_mac_conn_get_by_mci(const struct dect_cluster *cl, const struct dect_mci *mci)
  10054. +{
  10055. + struct dect_mac_conn *mc;
  10056. +
  10057. + list_for_each_entry(mc, &cl->mac_connections, list) {
  10058. + if (!dect_ari_cmp(&mc->mci.ari, &mci->ari) &&
  10059. + !dect_pmid_cmp(&mc->mci.pmid, &mci->pmid) &&
  10060. + mc->mci.lcn == mci->lcn)
  10061. + return mc;
  10062. + }
  10063. + return NULL;
  10064. +}
  10065. +EXPORT_SYMBOL_GPL(dect_mac_conn_get_by_mci);
  10066. +
  10067. +void dect_dlc_mac_conn_destroy(struct dect_mac_conn *mc)
  10068. +{
  10069. + mc_debug(mc, "destroy\n");
  10070. + list_del(&mc->list);
  10071. + kfree(mc);
  10072. +}
  10073. +
  10074. +void dect_dlc_mac_conn_bind(struct dect_mac_conn *mc)
  10075. +{
  10076. + mc_debug(mc, "bind use %u\n", mc->use);
  10077. + mc->use++;
  10078. +}
  10079. +EXPORT_SYMBOL_GPL(dect_dlc_mac_conn_bind);
  10080. +
  10081. +void dect_dlc_mac_conn_unbind(struct dect_mac_conn *mc)
  10082. +{
  10083. + mc_debug(mc, "unbind use %u\n", mc->use);
  10084. + if (--mc->use)
  10085. + return;
  10086. +
  10087. + if (mc->state == DECT_MAC_CONN_OPEN ||
  10088. + mc->state == DECT_MAC_CONN_OPEN_PENDING)
  10089. + dect_mac_dis_req(mc->cl, mc->mcei);
  10090. +
  10091. + dect_dlc_mac_conn_destroy(mc);
  10092. +}
  10093. +EXPORT_SYMBOL_GPL(dect_dlc_mac_conn_unbind);
  10094. +
  10095. +struct dect_mac_conn *dect_mac_conn_init(struct dect_cluster *cl,
  10096. + const struct dect_mci *mci,
  10097. + const struct dect_mbc_id *id)
  10098. +{
  10099. + struct dect_mac_conn *mc;
  10100. +
  10101. + mc = kzalloc(sizeof(*mc), GFP_ATOMIC);
  10102. + if (mc == NULL)
  10103. + return NULL;
  10104. +
  10105. + mc->cl = cl;
  10106. + mc->mcei = id != NULL ? id->mcei : dect_mbc_alloc_mcei(cl);
  10107. + memcpy(&mc->mci, mci, sizeof(mc->mci));
  10108. + mc->state = DECT_MAC_CONN_CLOSED;
  10109. + mc_debug(mc, "init\n");
  10110. +
  10111. + list_add_tail(&mc->list, &cl->mac_connections);
  10112. + return mc;
  10113. +}
  10114. +
  10115. +static void dect_mac_conn_state_change(struct dect_mac_conn *mc,
  10116. + enum dect_mac_conn_states state)
  10117. +{
  10118. + mc_debug(mc, "state change: %s (%u) -> %s (%u)\n",
  10119. + dect_mc_states[mc->state], mc->state,
  10120. + dect_mc_states[state], state);
  10121. +
  10122. + mc->state = state;
  10123. + dect_cplane_notify_state_change(mc);
  10124. +}
  10125. +
  10126. +int dect_dlc_mac_conn_establish(struct dect_mac_conn *mc,
  10127. + const struct dect_mac_conn_params *mcp)
  10128. +{
  10129. + struct dect_mbc_id mid = {
  10130. + .mcei = mc->mcei,
  10131. + .ari = mc->mci.ari,
  10132. + .pmid = mc->mci.pmid,
  10133. + .ecn = mc->mci.lcn,
  10134. + };
  10135. + int err;
  10136. +
  10137. + err = dect_mac_con_req(mc->cl, &mid, mcp);
  10138. + if (err < 0)
  10139. + return err;
  10140. + dect_mac_conn_state_change(mc, DECT_MAC_CONN_OPEN_PENDING);
  10141. + return 0;
  10142. +}
  10143. +
  10144. +int dect_mac_con_cfm(struct dect_cluster *cl, u32 mcei,
  10145. + const struct dect_mac_conn_params *mcp)
  10146. +{
  10147. + struct dect_mac_conn *mc;
  10148. +
  10149. + mc = dect_mac_conn_get_by_mcei(cl, mcei);
  10150. + if (WARN_ON(mc == NULL))
  10151. + return -ENOENT;
  10152. + mc->mcp = *mcp;
  10153. +
  10154. + mc_debug(mc, "MAC_CON-cfm\n");
  10155. + dect_mac_conn_state_change(mc, DECT_MAC_CONN_OPEN);
  10156. + return 0;
  10157. +}
  10158. +
  10159. +int dect_mac_con_ind(struct dect_cluster *cl, const struct dect_mbc_id *id,
  10160. + const struct dect_mac_conn_params *mcp)
  10161. +{
  10162. + struct dect_mac_conn *mc;
  10163. + struct dect_mci mci = {
  10164. + .ari = id->ari,
  10165. + .pmid = id->pmid,
  10166. + .lcn = id->ecn & DECT_LCN_MASK,
  10167. + };
  10168. +
  10169. + mc = dect_mac_conn_init(cl, &mci, id);
  10170. + if (mc == NULL)
  10171. + return -ENOMEM;
  10172. + mc->mcp = *mcp;
  10173. +
  10174. + mc_debug(mc, "MAC_CON-ind\n");
  10175. + dect_mac_conn_state_change(mc, DECT_MAC_CONN_OPEN);
  10176. + return 0;
  10177. +}
  10178. +
  10179. +int dect_dlc_mac_conn_enc_key_req(struct dect_mac_conn *mc, u64 ck)
  10180. +{
  10181. + mc->ck = ck;
  10182. + return dect_mac_enc_key_req(mc->cl, mc->mcei, ck);
  10183. +}
  10184. +
  10185. +int dect_dlc_mac_conn_enc_eks_req(struct dect_mac_conn *mc,
  10186. + enum dect_cipher_states status)
  10187. +{
  10188. + return dect_mac_enc_eks_req(mc->cl, mc->mcei, status);
  10189. +}
  10190. +
  10191. +/* Encryption status change confirmation from CCF */
  10192. +void dect_mac_enc_eks_cfm(struct dect_cluster *cl, u32 mcei,
  10193. + enum dect_cipher_states status)
  10194. +
  10195. +{
  10196. + struct dect_mac_conn *mc;
  10197. +
  10198. + mc = dect_mac_conn_get_by_mcei(cl, mcei);
  10199. + if (WARN_ON(mc == NULL))
  10200. + return;
  10201. + //dect_cplane_mac_enc_eks_ind(mc, status);
  10202. +}
  10203. +
  10204. +/* Encryption status change indication from CCF */
  10205. +void dect_mac_enc_eks_ind(struct dect_cluster *cl, u32 mcei,
  10206. + enum dect_cipher_states status)
  10207. +
  10208. +{
  10209. + struct dect_mac_conn *mc;
  10210. +
  10211. + mc = dect_mac_conn_get_by_mcei(cl, mcei);
  10212. + if (WARN_ON(mc == NULL))
  10213. + return;
  10214. + mc_debug(mc, "MAC_ENC_EKS-ind: status: %u\n", status);
  10215. + dect_cplane_mac_enc_eks_ind(mc, status);
  10216. +}
  10217. +
  10218. +/* Disconnection indication from CCF */
  10219. +int dect_mac_dis_ind(struct dect_cluster *cl, u32 mcei,
  10220. + enum dect_release_reasons reason)
  10221. +{
  10222. + struct dect_mac_conn *mc;
  10223. +
  10224. + mc = dect_mac_conn_get_by_mcei(cl, mcei);
  10225. + if (WARN_ON(mc == NULL))
  10226. + return -ENOENT;
  10227. +
  10228. + mc_debug(mc, "MAC_DIS-ind: reason: %x\n", reason);
  10229. + dect_mac_conn_state_change(mc, DECT_MAC_CONN_CLOSED);
  10230. + /* If nothing is using the connection, release immediately */
  10231. + if (mc->use == 0)
  10232. + dect_dlc_mac_conn_destroy(mc);
  10233. + else
  10234. + dect_cplane_mac_dis_ind(mc, reason);
  10235. + return 0;
  10236. +}
  10237. +
  10238. +/* Data indication from CCF */
  10239. +void dect_mac_co_data_ind(struct dect_cluster *cl, u32 mcei,
  10240. + enum dect_data_channels chan,
  10241. + struct sk_buff *skb)
  10242. +{
  10243. + struct dect_mac_conn *mc;
  10244. +
  10245. + mc = dect_mac_conn_get_by_mcei(cl, mcei);
  10246. + if (WARN_ON(mc == NULL))
  10247. + goto err;
  10248. +
  10249. + mc_debug(mc, "MAC_CO_DATA-ind: chan: %u len: %u\n", chan, skb->len);
  10250. + switch (chan) {
  10251. + case DECT_MC_C_S:
  10252. + case DECT_MC_C_F:
  10253. + return dect_cplane_rcv(mc, chan, skb);
  10254. + case DECT_MC_I_N:
  10255. + case DECT_MC_I_P:
  10256. + return dect_uplane_rcv(mc, chan, skb);
  10257. + default:
  10258. + goto err;
  10259. + }
  10260. +err:
  10261. + kfree_skb(skb);
  10262. +}
  10263. +
  10264. +/* Data-ready indication from CCF */
  10265. +struct sk_buff *dect_mac_co_dtr_ind(struct dect_cluster *cl, u32 mcei,
  10266. + enum dect_data_channels chan)
  10267. +{
  10268. + struct dect_mac_conn *mc;
  10269. +
  10270. + mc = dect_mac_conn_get_by_mcei(cl, mcei);
  10271. + if (mc == NULL) {
  10272. + if (net_ratelimit())
  10273. + pr_debug("DLC: DTR no connection\n");
  10274. + return NULL;
  10275. + }
  10276. +
  10277. + mc_debug(mc, "MAC_CO_DTR-ind: chan: %u\n", chan);
  10278. + switch (chan) {
  10279. + case DECT_MC_C_S:
  10280. + case DECT_MC_C_F:
  10281. + return dect_cplane_dtr(mc, chan);
  10282. + case DECT_MC_I_N:
  10283. + case DECT_MC_I_P:
  10284. + return dect_uplane_dtr(mc, chan);
  10285. + default:
  10286. + return NULL;
  10287. + }
  10288. +}
  10289. diff --git a/net/dect/dlc_b_sap.c b/net/dect/dlc_b_sap.c
  10290. new file mode 100644
  10291. index 0000000..28782d4
  10292. --- /dev/null
  10293. +++ b/net/dect/dlc_b_sap.c
  10294. @@ -0,0 +1,278 @@
  10295. +/*
  10296. + * DECT DLC B SAP sockets - DLC C-plane broadcast service access
  10297. + *
  10298. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  10299. + *
  10300. + * This program is free software; you can redistribute it and/or modify
  10301. + * it under the terms of the GNU General Public License version 2 as
  10302. + * published by the Free Software Foundation.
  10303. + */
  10304. +
  10305. +#include <linux/kernel.h>
  10306. +#include <linux/module.h>
  10307. +#include <linux/init.h>
  10308. +#include <linux/net.h>
  10309. +#include <linux/socket.h>
  10310. +#include <linux/dect.h>
  10311. +#include <net/sock.h>
  10312. +#include <net/dect/dect.h>
  10313. +
  10314. +static DEFINE_SPINLOCK(dect_bsap_lock);
  10315. +static HLIST_HEAD(dect_bsap_sockets);
  10316. +
  10317. +struct dect_bsap {
  10318. + struct sock sk;
  10319. +};
  10320. +
  10321. +static inline struct dect_bsap *dect_bsap(struct sock *sk)
  10322. +{
  10323. + return (struct dect_bsap *)sk;
  10324. +}
  10325. +
  10326. +void dect_bsap_rcv(const struct dect_cluster *cl, struct sk_buff *skb)
  10327. +{
  10328. + struct hlist_node *node;
  10329. + struct sk_buff *skb2;
  10330. + struct sock *sk, *prev = NULL;
  10331. +
  10332. + spin_lock(&dect_bsap_lock);
  10333. + sk_for_each(sk, &dect_bsap_sockets) {
  10334. + if (sk->sk_bound_dev_if &&
  10335. + sk->sk_bound_dev_if != cl->index)
  10336. + continue;
  10337. +
  10338. + skb2 = skb_clone(skb, GFP_ATOMIC);
  10339. + if (skb2 == NULL) {
  10340. + sk->sk_err = -ENOMEM;
  10341. + sk->sk_error_report(sk);
  10342. + break;
  10343. + }
  10344. +
  10345. + if (prev != NULL) {
  10346. + if (dect_sock_queue_rcv_skb(prev, skb2) < 0)
  10347. + kfree_skb(skb2);
  10348. + }
  10349. + prev = sk;
  10350. + }
  10351. +
  10352. + if (prev == NULL || dect_sock_queue_rcv_skb(prev, skb) < 0)
  10353. + kfree_skb(skb);
  10354. +
  10355. + spin_unlock(&dect_bsap_lock);
  10356. +}
  10357. +
  10358. +static void dect_bsap_close(struct sock *sk, long timeout)
  10359. +{
  10360. + sk_common_release(sk);
  10361. +}
  10362. +
  10363. +static int dect_bsap_bind(struct sock *sk, struct sockaddr *uaddr, int len)
  10364. +{
  10365. + const struct sockaddr_dect *addr = (struct sockaddr_dect *)uaddr;
  10366. + int err;
  10367. +
  10368. + if (len < sizeof(*addr) || addr->dect_family != AF_DECT)
  10369. + return -EINVAL;
  10370. +
  10371. + if (addr->dect_index != 0 &&
  10372. + !dect_cluster_get_by_index(addr->dect_index))
  10373. + return -ENODEV;
  10374. +
  10375. + lock_sock(sk);
  10376. + err = -EINVAL;
  10377. + if (!sk_unhashed(sk))
  10378. + goto out;
  10379. +
  10380. + sk->sk_bound_dev_if = addr->dect_index;
  10381. +
  10382. + spin_lock_bh(&dect_bsap_lock);
  10383. + sk_add_node(sk, &dect_bsap_sockets);
  10384. + spin_unlock_bh(&dect_bsap_lock);
  10385. +
  10386. + err = 0;
  10387. +out:
  10388. + release_sock(sk);
  10389. + return err;
  10390. +}
  10391. +
  10392. +static void dect_bsap_unhash(struct sock *sk)
  10393. +{
  10394. + if (sk_hashed(sk)) {
  10395. + spin_lock_bh(&dect_bsap_lock);
  10396. + sk_del_node_init(sk);
  10397. + spin_unlock_bh(&dect_bsap_lock);
  10398. + }
  10399. +}
  10400. +
  10401. +static int dect_bsap_getname(struct sock *sk, struct sockaddr *uaddr, int *len,
  10402. + int peer)
  10403. +{
  10404. + struct sockaddr_dect *addr = (struct sockaddr_dect *)uaddr;
  10405. +
  10406. + if (peer)
  10407. + return -EOPNOTSUPP;
  10408. +
  10409. + addr->dect_family = AF_DECT;
  10410. + addr->dect_index = sk->sk_bound_dev_if;
  10411. + *len = sizeof(*addr);
  10412. + return 0;
  10413. +}
  10414. +
  10415. +static int dect_bsap_recvmsg(struct sock *sk,
  10416. + struct msghdr *msg, size_t len,
  10417. + int noblock, int flags, int *addrlen)
  10418. +{
  10419. + struct sockaddr_dect *addr;
  10420. + struct dect_bsap_auxdata aux;
  10421. + struct sk_buff *skb;
  10422. + size_t copied = 0;
  10423. + int err;
  10424. +
  10425. + if (flags & MSG_OOB)
  10426. + return -EOPNOTSUPP;
  10427. +
  10428. + skb = skb_recv_datagram(sk, flags, noblock, &err);
  10429. + if (skb == NULL)
  10430. + goto out;
  10431. +
  10432. + //msg->msg_flags |= DECT_LB_CB(skb)->expedited ? MSG_OOB : 0;
  10433. +
  10434. + copied = skb->len;
  10435. + if (len < copied) {
  10436. + msg->msg_flags |= MSG_TRUNC;
  10437. + copied = len;
  10438. + }
  10439. +
  10440. + err = skb_copy_datagram_msg(skb, 0, msg, copied);
  10441. + if (err < 0)
  10442. + goto out_free;
  10443. +
  10444. + if (msg->msg_name != NULL) {
  10445. + addr = (struct sockaddr_dect *)msg->msg_name;
  10446. + addr->dect_family = AF_DECT;
  10447. + addr->dect_index = DECT_SK_CB(skb)->index;
  10448. + msg->msg_namelen = sizeof(*addr);
  10449. + }
  10450. +
  10451. + sock_recv_timestamp(msg, sk, skb);
  10452. +
  10453. + aux.long_page = DECT_BMC_CB(skb)->long_page;
  10454. + put_cmsg(msg, SOL_DECT, DECT_BSAP_AUXDATA, sizeof(aux), &aux);
  10455. +
  10456. + if (flags & MSG_TRUNC)
  10457. + copied = skb->len;
  10458. +out_free:
  10459. + skb_free_datagram(sk, skb);
  10460. +out:
  10461. + return err ? : copied;
  10462. +}
  10463. +
  10464. +static int dect_bsap_sendmsg(struct sock *sk,
  10465. + struct msghdr *msg, size_t len)
  10466. +{
  10467. + const struct sockaddr_dect *addr = msg->msg_name;
  10468. + bool expedited = msg->msg_flags & MSG_OOB;
  10469. + struct dect_cluster *cl;
  10470. + struct sk_buff *skb;
  10471. + struct cmsghdr *cmsg;
  10472. + struct dect_bsap_auxdata *aux;
  10473. + bool long_page = false;
  10474. + int index;
  10475. + int err;
  10476. +
  10477. + if (msg->msg_namelen) {
  10478. + if (addr->dect_family != AF_DECT)
  10479. + return -EINVAL;
  10480. + index = addr->dect_index;
  10481. + } else
  10482. + index = sk->sk_bound_dev_if;
  10483. +
  10484. + /* Transmission is always in direction FP -> PP */
  10485. + cl = dect_cluster_get_by_index(index);
  10486. + if (cl == NULL)
  10487. + return -ENODEV;
  10488. + if (cl->mode != DECT_MODE_FP)
  10489. + return -EOPNOTSUPP;
  10490. +
  10491. + for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg)) {
  10492. + if (!CMSG_OK(msg, cmsg))
  10493. + return -EINVAL;
  10494. + if (cmsg->cmsg_level != SOL_DECT)
  10495. + continue;
  10496. +
  10497. + switch (cmsg->cmsg_type) {
  10498. + case DECT_BSAP_AUXDATA:
  10499. + if (cmsg->cmsg_len != CMSG_LEN(sizeof(*aux)))
  10500. + return -EINVAL;
  10501. + aux = (struct dect_bsap_auxdata *)CMSG_DATA(cmsg);
  10502. + long_page = aux->long_page;
  10503. + break;
  10504. + default:
  10505. + return -EINVAL;
  10506. + }
  10507. + }
  10508. +
  10509. + /* Valid frame sizes are 3 bytes (short frame), 5 bytes (long frame)
  10510. + * or multiples of 5 bytes up to 30 bytes (extended frame). Extended
  10511. + * frames can not use expedited operation. */
  10512. + if (len == DECT_LB_SHORT_FRAME_SIZE) {
  10513. + if (long_page)
  10514. + return -EINVAL;
  10515. + } else if (len % DECT_LB_LONG_FRAME_SIZE == 0) {
  10516. + if (len == 0 || len > DECT_LB_EXTENDED_FRAME_SIZE_MAX)
  10517. + return -EMSGSIZE;
  10518. + if (len > DECT_LB_LONG_FRAME_SIZE && !long_page)
  10519. + return -EINVAL;
  10520. + if (expedited)
  10521. + return -EOPNOTSUPP;
  10522. + } else
  10523. + return -EINVAL;
  10524. +
  10525. + skb = sock_alloc_send_skb(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
  10526. + if (skb == NULL)
  10527. + goto err1;
  10528. + err = memcpy_from_msg(skb_put(skb, len), msg, len);
  10529. + if (err < 0)
  10530. + goto err2;
  10531. + DECT_BMC_CB(skb)->long_page = long_page;
  10532. + DECT_BMC_CB(skb)->fast_page = expedited;
  10533. + dect_bmc_mac_page_req(cl, skb);
  10534. + return len;
  10535. +
  10536. +err2:
  10537. + kfree_skb(skb);
  10538. +err1:
  10539. + return err;
  10540. +}
  10541. +
  10542. +static struct dect_proto dect_bsap_proto __read_mostly = {
  10543. + .type = SOCK_DGRAM,
  10544. + .protocol = DECT_B_SAP,
  10545. + .capability = CAP_NET_RAW,
  10546. + .ops = &dect_dgram_ops,
  10547. + .proto.name = "DECT_B_SAP",
  10548. + .proto.owner = THIS_MODULE,
  10549. + .proto.obj_size = sizeof(struct dect_bsap),
  10550. + .proto.close = dect_bsap_close,
  10551. + .proto.bind = dect_bsap_bind,
  10552. + .proto.unhash = dect_bsap_unhash,
  10553. + .proto.recvmsg = dect_bsap_recvmsg,
  10554. + .proto.sendmsg = dect_bsap_sendmsg,
  10555. + .getname = dect_bsap_getname,
  10556. +};
  10557. +
  10558. +int __init dect_bsap_module_init(void)
  10559. +{
  10560. + return dect_proto_register(&dect_bsap_proto);
  10561. +}
  10562. +
  10563. +void dect_bsap_module_exit(void)
  10564. +{
  10565. + dect_proto_unregister(&dect_bsap_proto);
  10566. +}
  10567. +
  10568. +MODULE_AUTHOR("Patrick McHardy <[email protected]>");
  10569. +MODULE_DESCRIPTION("DECT DLC B SAP sockets");
  10570. +MODULE_LICENSE("GPL");
  10571. +
  10572. +MODULE_ALIAS_NET_PF_PROTO(PF_DECT, DECT_B_SAP);
  10573. diff --git a/net/dect/dlc_cplane.c b/net/dect/dlc_cplane.c
  10574. new file mode 100644
  10575. index 0000000..9365b9d
  10576. --- /dev/null
  10577. +++ b/net/dect/dlc_cplane.c
  10578. @@ -0,0 +1,981 @@
  10579. +/*
  10580. + * DECT DLC C-plane
  10581. + *
  10582. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  10583. + *
  10584. + * This program is free software; you can redistribute it and/or modify
  10585. + * it under the terms of the GNU General Public License version 2 as
  10586. + * published by the Free Software Foundation.
  10587. + */
  10588. +
  10589. +#ifdef CONFIG_DECT_DEBUG
  10590. +#define DEBUG
  10591. +#endif
  10592. +
  10593. +#include <linux/kernel.h>
  10594. +#include <linux/module.h>
  10595. +#include <linux/init.h>
  10596. +#include <linux/list.h>
  10597. +#include <linux/skbuff.h>
  10598. +#include <linux/net.h>
  10599. +#include <linux/dect.h>
  10600. +#include <net/dect/dect.h>
  10601. +
  10602. +void dect_mac_page_ind(struct dect_cluster *cl, struct sk_buff *skb)
  10603. +{
  10604. + dect_bsap_rcv(cl, skb);
  10605. +}
  10606. +
  10607. +static void dect_fa_parse_len(struct dect_fa_len *len, const struct sk_buff *skb)
  10608. +{
  10609. + u8 l;
  10610. +
  10611. + l = skb->data[DECT_FA_LI_OFF];
  10612. + len->len = (l & DECT_FA_LI_LENGTH_MASK) >> DECT_FA_LI_LENGTH_SHIFT;
  10613. + len->more = (l & DECT_FA_LI_M_FLAG);
  10614. +}
  10615. +
  10616. +/*
  10617. + * LAPC entity
  10618. + */
  10619. +
  10620. +#define lapc_debug(lapc, fmt, args...) \
  10621. + pr_debug("LAPC (MCEI: %u LLN: %u): " fmt, \
  10622. + (lapc)->lc->mc->mcei, (lapc)->dli.lln, ## args)
  10623. +
  10624. +static inline u8 lapc_seq_add(const struct dect_lapc *lapc, u8 s1, u8 s2)
  10625. +{
  10626. + return (s1 + s2) & (lapc->mod - 1);
  10627. +}
  10628. +
  10629. +static inline bool dect_fa_seq_before(const struct dect_lapc *lapc, u8 s1, u8 s2)
  10630. +{
  10631. + if (lapc->window == 1)
  10632. + return s1 != s2;
  10633. + else
  10634. + return (s8)((s2 << 5) - (s1 << 5)) > 0;
  10635. +}
  10636. +
  10637. +static inline bool dect_fa_seq_after(const struct dect_lapc *lapc, u8 s1, u8 s2)
  10638. +{
  10639. + return dect_fa_seq_before(lapc, s2, s1);
  10640. +}
  10641. +
  10642. +static void dect_lapc_transmit_skb(struct dect_lapc *lapc)
  10643. +{
  10644. + struct sk_buff *skb = skb_peek(&lapc->retransmit_queue);
  10645. + struct dect_fa_hdr *fh;
  10646. +
  10647. + skb = skb_clone(skb, GFP_ATOMIC);
  10648. + if (skb == NULL)
  10649. + return;
  10650. +
  10651. + fh = (struct dect_fa_hdr *)skb->data;
  10652. + lapc_debug(lapc, "queue I-frame: v_a: %u v_r: %u v_s: %u "
  10653. + "len: %u addr: %02x ctrl: %02x\n", lapc->v_a, lapc->v_r,
  10654. + lapc->v_s, skb->len, fh->addr, fh->ctrl);
  10655. + skb_queue_tail(&lapc->lc->txq, skb);
  10656. +}
  10657. +
  10658. +static void dect_lapc_error_report(struct dect_lapc *lapc, int err)
  10659. +{
  10660. + struct sock *sk = lapc->sk;
  10661. +
  10662. + lapc_debug(lapc, "socket error: %d\n", err);
  10663. + sk->sk_err = err;
  10664. + sk->sk_error_report(sk);
  10665. +}
  10666. +
  10667. +static void dect_lapc_state_change(struct dect_lapc *lapc, int state)
  10668. +{
  10669. + struct sock *sk = lapc->sk;
  10670. +
  10671. + lapc_debug(lapc, "socket state change: %d\n", state);
  10672. + sk->sk_state = state;
  10673. + sk->sk_state_change(sk);
  10674. +}
  10675. +
  10676. +/**
  10677. + * dect_lapc_timeout - retransmission timer
  10678. + *
  10679. + * Handle missing acknowledgements:
  10680. + *
  10681. + * - If not already in timer recovery condition, enter it
  10682. + * - otherwise add one to retransmission count
  10683. + *
  10684. + * If the retransmission count is below the maximum, restart the timer and
  10685. + * send an "appropriate" S-frame acknowledgement or retransmit the last
  10686. + * I-frame, in both cases with the poll bit set.
  10687. + */
  10688. +static void dect_lapc_timeout(unsigned long data)
  10689. +{
  10690. + struct dect_lapc *lapc = (struct dect_lapc *)data;
  10691. +
  10692. + lapc_debug(lapc, "retransmission timer: cnt: %u\n", lapc->retransmit_cnt);
  10693. + if (lapc->retransmit_cnt++ < DECT_LAPC_RETRANSMIT_MAX) {
  10694. + dect_lapc_transmit_skb(lapc);
  10695. + mod_timer(&lapc->timer, jiffies + DECT_LAPC_CLASS_A_ESTABLISH_TIMEOUT);
  10696. + } else
  10697. + dect_lapc_error_report(lapc, ETIMEDOUT);
  10698. +}
  10699. +
  10700. +static bool dect_lapc_done(const struct dect_lapc *lapc)
  10701. +{
  10702. + return skb_queue_empty(&lapc->sk->sk_write_queue) &&
  10703. + skb_queue_empty(&lapc->retransmit_queue);
  10704. +}
  10705. +
  10706. +void dect_lapc_destroy(struct dect_lapc *lapc)
  10707. +{
  10708. + lapc_debug(lapc, "destroy\n");
  10709. +
  10710. + del_timer_sync(&lapc->timer);
  10711. + skb_queue_purge(&lapc->retransmit_queue);
  10712. + dect_lc_unbind(lapc->lc, lapc);
  10713. + sock_put(lapc->sk);
  10714. + kfree(lapc);
  10715. +}
  10716. +
  10717. +static void dect_lapc_reset(struct dect_lapc *lapc)
  10718. +{
  10719. + lapc->nlf = true;
  10720. + lapc->v_s = 0;
  10721. + lapc->v_a = 0;
  10722. + lapc->v_r = 0;
  10723. +}
  10724. +
  10725. +/**
  10726. + * dect_lapc_init - initialize a new LAPC entity
  10727. + */
  10728. +struct dect_lapc *dect_lapc_init(struct sock *sk, const struct dect_dli *dli,
  10729. + enum dect_sapis sapi, struct dect_lc *lc,
  10730. + gfp_t gfp)
  10731. +{
  10732. + struct dect_lapc *lapc;
  10733. +
  10734. + lapc = kzalloc(sizeof(*lapc), gfp);
  10735. + if (lapc == NULL)
  10736. + return NULL;
  10737. +
  10738. + lapc->sk = sk;
  10739. + sock_hold(sk);
  10740. +
  10741. + memcpy(&lapc->dli, dli, sizeof(lapc->dli));
  10742. + lapc->sapi = sapi;
  10743. + lapc->state = DECT_LAPC_ULI;
  10744. + skb_queue_head_init(&lapc->retransmit_queue);
  10745. +
  10746. + lapc->lc = lc;
  10747. + setup_timer(&lapc->timer, dect_lapc_timeout, (unsigned long)lapc);
  10748. + lapc->cmd = (lc->mc->cl->mode == DECT_MODE_FP) ? true : false;
  10749. +
  10750. + switch (lapc->dli.lln) {
  10751. + case DECT_LLN_CLASS_U:
  10752. + break;
  10753. + case DECT_LLN_CLASS_A:
  10754. + lapc->window = DECT_LAPC_CLASS_A_WINDOW;
  10755. + lapc->mod = DECT_LAPC_CLASS_A_MOD;
  10756. + break;
  10757. + default:
  10758. + lapc->window = DECT_LAPC_CLASS_B_INITIAL_WINDOW;
  10759. + lapc->mod = DECT_LAPC_CLASS_B_MOD;
  10760. + break;
  10761. + }
  10762. +
  10763. + dect_lapc_reset(lapc);
  10764. +
  10765. + lapc_debug(lapc, "init\n");
  10766. + return lapc;
  10767. +}
  10768. +
  10769. +#define DECT_FA_FRAME_RESERVE 16
  10770. +#define DECT_FA_FRAME_SPACE 16
  10771. +
  10772. +static struct sk_buff *dect_lapc_alloc_skb(struct dect_lapc *lapc)
  10773. +{
  10774. + struct sk_buff *skb;
  10775. +
  10776. + skb = alloc_skb(DECT_FA_FRAME_SPACE + DECT_FA_FRAME_RESERVE, GFP_ATOMIC);
  10777. + if (skb == NULL)
  10778. + return NULL;
  10779. + skb_reset_mac_header(skb);
  10780. + skb_reserve(skb, DECT_FA_FRAME_RESERVE);
  10781. + skb_reserve(skb, DECT_FA_HDR_SIZE);
  10782. + skb_reset_network_header(skb);
  10783. + return skb;
  10784. +}
  10785. +
  10786. +static struct dect_fa_hdr *dect_prepare_fa_frame(const struct dect_lapc *lapc,
  10787. + bool command,
  10788. + struct sk_buff *skb)
  10789. +{
  10790. + struct dect_fa_hdr *fh;
  10791. + u8 ilen = skb->len;
  10792. +
  10793. + fh = (struct dect_fa_hdr *)skb_push(skb, DECT_FA_HDR_SIZE);
  10794. + fh->addr = lapc->dli.lln << DECT_FA_ADDR_LLN_SHIFT;
  10795. + fh->addr |= lapc->sapi << DECT_FA_ADDR_SAPI_SHIFT;
  10796. + fh->addr |= DECT_FA_ADDR_RES_BIT;
  10797. + fh->addr |= (command ? lapc->cmd : !lapc->cmd) ? DECT_FA_ADDR_CR_FLAG : 0;
  10798. + fh->addr |= lapc->nlf ? DECT_FA_ADDR_NLF_FLAG : 0;
  10799. + fh->ctrl = 0;
  10800. + fh->li = ilen << DECT_FA_LI_LENGTH_SHIFT;
  10801. + fh->li |= DECT_FA_LI_EXT_FLAG;
  10802. + return fh;
  10803. +}
  10804. +
  10805. +static bool dect_lapc_send_iframe(struct dect_lapc *lapc, bool pf)
  10806. +{
  10807. + struct dect_fa_hdr *fh;
  10808. + struct sk_buff *skb;
  10809. +
  10810. + /* Window size full? */
  10811. + lapc_debug(lapc, "send I-frame: v_a: %u window: %u v_s: %u\n",
  10812. + lapc->v_a, lapc->window, lapc->v_s);
  10813. + if (lapc_seq_add(lapc, lapc->v_a, lapc->window) == lapc->v_s)
  10814. + return false;
  10815. +
  10816. + /* Prepare a new I-frame */
  10817. + skb = skb_dequeue(&lapc->sk->sk_write_queue);
  10818. + if (skb == NULL)
  10819. + return false;
  10820. + fh = dect_prepare_fa_frame(lapc, true, skb);
  10821. + fh->ctrl |= DECT_FA_CTRL_I_FMT_ID;
  10822. + fh->ctrl |= lapc->v_r << DECT_FA_CTRL_I_NR_SHIFT;
  10823. + fh->ctrl |= lapc->v_s << DECT_FA_CTRL_I_NS_SHIFT;
  10824. + fh->ctrl |= pf ? DECT_FA_CTRL_I_P_FLAG : 0;
  10825. +
  10826. + /* Append to retransmission queue and (re)start retransmission timer */
  10827. + skb_queue_tail(&lapc->retransmit_queue, skb);
  10828. + if (!timer_pending(&lapc->timer))
  10829. + mod_timer(&lapc->timer, jiffies + DECT_LAPC_RETRANSMISSION_TIMEOUT);
  10830. +
  10831. + lapc->v_s = lapc_seq_add(lapc, lapc->v_s, 1);
  10832. +
  10833. + dect_lapc_transmit_skb(lapc);
  10834. + return true;
  10835. +}
  10836. +
  10837. +/*
  10838. + * Send a S-frame with the specified command. The command/response bit setting
  10839. + * depends on the role of the LAPC, a PP uses 0 for commands and 1 for responses,
  10840. + * a FT 1 for commands and 0 for responses.
  10841. + */
  10842. +static bool dect_lapc_send_sframe(struct dect_lapc *lapc, u8 cr,
  10843. + bool command, bool pf)
  10844. +{
  10845. + struct dect_fa_hdr *fh;
  10846. + struct sk_buff *skb;
  10847. +
  10848. + skb = dect_lapc_alloc_skb(lapc);
  10849. + if (skb == NULL)
  10850. + return false;
  10851. +
  10852. + fh = dect_prepare_fa_frame(lapc, command, skb);
  10853. + fh->ctrl |= DECT_FA_CTRL_S_FMT_ID;
  10854. + fh->ctrl |= lapc->v_r << DECT_FA_CTRL_S_NR_SHIFT;
  10855. + fh->ctrl |= cr;
  10856. + fh->ctrl |= pf ? DECT_FA_CTRL_S_PF_FLAG : 0;
  10857. +
  10858. + lapc_debug(lapc, "queue S-frame: v_r: %u len: %u addr: %02x ctrl: %02x\n",
  10859. + lapc->v_r, skb->len, fh->addr, fh->ctrl);
  10860. + skb_queue_tail(&lapc->lc->txq, skb);
  10861. +
  10862. + lapc->nlf = false;
  10863. + return true;
  10864. +}
  10865. +
  10866. +/*
  10867. + * Send an acknowledgement frame. Class B entities use RNR responses to indicate
  10868. + * their status while busy. Otherwise an I-frame is used when data is available
  10869. + * and a RR response frame otherwise.
  10870. + */
  10871. +static void dect_lapc_send_ack(struct dect_lapc *lapc, bool pf)
  10872. +{
  10873. + lapc_debug(lapc, "send ACK: I-frame present: %u\n",
  10874. + skb_peek(&lapc->sk->sk_write_queue) ? 1 : 0);
  10875. + if (lapc->dli.lln != DECT_LLN_CLASS_A && lapc->busy)
  10876. + dect_lapc_send_sframe(lapc, DECT_FA_CTRL_S_CR_RNR, false, false);
  10877. + else if (!lapc->peer_busy && skb_peek(&lapc->sk->sk_write_queue))
  10878. + dect_lapc_send_iframe(lapc, pf);
  10879. + else
  10880. + dect_lapc_send_sframe(lapc, DECT_FA_CTRL_S_CR_RR, false, pf);
  10881. +}
  10882. +
  10883. +static void dect_lapc_queue_data(struct dect_lapc *lapc, struct sk_buff *skb)
  10884. +{
  10885. + struct dect_fa_hdr *fh = (struct dect_fa_hdr *)skb->data;
  10886. +
  10887. + skb_pull(skb, DECT_FA_HDR_SIZE);
  10888. + if (skb->len == 0) {
  10889. + kfree_skb(skb);
  10890. + return;
  10891. + }
  10892. + lapc_debug(lapc, "reassemble message: segment len: %u more: %u\n",
  10893. + skb->len, (fh->li & DECT_FA_LI_M_FLAG) ? 1 : 0);
  10894. +
  10895. + lapc->rcv_head = skb_append_frag(lapc->rcv_head, skb);
  10896. + if (!(fh->li & DECT_FA_LI_M_FLAG)) {
  10897. + skb = lapc->rcv_head;
  10898. + lapc->rcv_head = NULL;
  10899. + lapc_debug(lapc, "reassembled message: len: %u\n", skb->len);
  10900. + sock_queue_rcv_skb(lapc->sk, skb);
  10901. + }
  10902. +}
  10903. +
  10904. +static bool dect_lapc_update_ack(struct dect_lapc *lapc, u8 seq)
  10905. +{
  10906. + u8 v_a = lapc->v_a;
  10907. +
  10908. + lapc_debug(lapc, "update ACK: v_a: %u v_s: %u seq: %u\n",
  10909. + lapc->v_a, lapc->v_s, seq);
  10910. +#if 0
  10911. + lapc_debug(lapc, "seq %u after v_a %u: %u\n", seq, lapc->v_a,
  10912. + dect_fa_seq_after(lapc, seq, lapc->v_a));
  10913. + lapc_debug(lapc, "v_s %u !after seq %u: %u\n", lapc->v_s, seq,
  10914. + !dect_fa_seq_after(lapc, lapc->v_s, seq));
  10915. +#endif
  10916. +
  10917. + /* If all outstanding I-frames have been acknowledged, stop
  10918. + * retransmission timer, otherwise reset it.
  10919. + */
  10920. + if (dect_fa_seq_after(lapc, seq, lapc->v_a) &&
  10921. + !dect_fa_seq_after(lapc, lapc->v_s, seq)) {
  10922. + lapc->v_a = seq;
  10923. + if (lapc->v_a == lapc->v_s) {
  10924. + del_timer_sync(&lapc->timer);
  10925. + lapc->retransmit_cnt = 0;
  10926. + } else
  10927. + mod_timer(&lapc->timer, jiffies + DECT_LAPC_RETRANSMISSION_TIMEOUT);
  10928. + } else if (seq != lapc->v_a)
  10929. + return false;
  10930. +
  10931. + /* Purge acknowledged frames from transmit queue */
  10932. + while (v_a != lapc->v_a) {
  10933. + lapc_debug(lapc, "purge retransmit queue: seq: %u\n", v_a);
  10934. + kfree_skb(skb_dequeue(&lapc->retransmit_queue));
  10935. + v_a = lapc_seq_add(lapc, v_a, 1);
  10936. + }
  10937. +
  10938. + if (lapc->sk->sk_state == DECT_SK_RELEASE_PENDING &&
  10939. + dect_lapc_done(lapc)) {
  10940. + dect_lapc_state_change(lapc, DECT_SK_RELEASED);
  10941. + dect_lapc_destroy(lapc);
  10942. + return false;
  10943. + }
  10944. +
  10945. + return true;
  10946. +}
  10947. +
  10948. +/*
  10949. + * Receive a Class A or Class B I-frame. Frames with valid sequence numbers
  10950. + * are acknowledged and queued for segment reassembly. Invalid sequence
  10951. + * numbers cause an ACK with the expected sequence number to be sent.
  10952. + *
  10953. + * Class B entities need to indicate their receiver busy status when busy or
  10954. + * when explicitly polled.
  10955. + */
  10956. +static void dect_lapc_rcv_iframe(struct dect_lapc *lapc, struct sk_buff *skb)
  10957. +{
  10958. + struct dect_fa_hdr *fh = (struct dect_fa_hdr *)skb->data;
  10959. + bool poll = false;
  10960. + u8 n_s, n_r, res;
  10961. +
  10962. + if (lapc->dli.lln == DECT_LLN_CLASS_U) {
  10963. + kfree_skb(skb);
  10964. + return;
  10965. + }
  10966. +
  10967. + if (fh->addr & DECT_FA_ADDR_NLF_FLAG)
  10968. + dect_lapc_reset(lapc);
  10969. +
  10970. + n_r = (fh->ctrl & DECT_FA_CTRL_I_NR_MASK) >> DECT_FA_CTRL_I_NR_SHIFT;
  10971. + n_s = (fh->ctrl & DECT_FA_CTRL_I_NS_MASK) >> DECT_FA_CTRL_I_NS_SHIFT;
  10972. + if (lapc->dli.lln != DECT_LLN_CLASS_A)
  10973. + poll = fh->ctrl & DECT_FA_CTRL_I_P_FLAG;
  10974. +
  10975. + lapc_debug(lapc, "receive I-frame: n_r: %u n_s: %u poll: %u\n",
  10976. + n_r, n_s, poll);
  10977. + dect_lapc_update_ack(lapc, n_r);
  10978. +
  10979. + /* While in receiver busy condition, all I-frames are dropped after
  10980. + * updating the acknowledgement number. In Class B mode receiver status
  10981. + * queries are still answered.
  10982. + */
  10983. + if (lapc->busy) {
  10984. + kfree_skb(skb);
  10985. + if (poll)
  10986. + goto poll;
  10987. + return;
  10988. + }
  10989. +
  10990. + /* When the frame contains an invalid sequence number, send an
  10991. + * immediate ACK. */
  10992. + if (n_s != lapc->v_r) {
  10993. + lapc_debug(lapc, "invalid sequence number %u %u\n", n_s, lapc->v_r);
  10994. + kfree_skb(skb);
  10995. + goto ack;
  10996. + }
  10997. +
  10998. + lapc->v_r = lapc_seq_add(lapc, lapc->v_r, 1);
  10999. + dect_lapc_queue_data(lapc, skb);
  11000. + if (poll)
  11001. + goto poll;
  11002. +ack:
  11003. + return dect_lapc_send_ack(lapc, poll);
  11004. +
  11005. +poll:
  11006. + res = lapc->busy ? DECT_FA_CTRL_S_CR_RNR : DECT_FA_CTRL_S_CR_RR;
  11007. + dect_lapc_send_sframe(lapc, res, false, true);
  11008. +}
  11009. +
  11010. +static void dect_lapc_rcv_sframe(struct dect_lapc *lapc, struct sk_buff *skb)
  11011. +{
  11012. + struct dect_fa_hdr *fh = (struct dect_fa_hdr *)skb->data;
  11013. + bool pf;
  11014. + u8 n_r;
  11015. +
  11016. + n_r = (fh->ctrl & DECT_FA_CTRL_S_NR_MASK) >> DECT_FA_CTRL_S_NR_SHIFT;
  11017. + pf = (fh->ctrl & DECT_FA_CTRL_S_PF_FLAG);
  11018. + lapc_debug(lapc, "receive S-frame: n_r: %u pf: %u\n", n_r, pf);
  11019. +
  11020. + switch (fh->ctrl & DECT_FA_CTRL_S_CR_MASK) {
  11021. + case DECT_FA_CTRL_S_CR_RR:
  11022. + if (!dect_lapc_update_ack(lapc, n_r))
  11023. + goto err;
  11024. +
  11025. + if (lapc->lc->elapc == lapc) {
  11026. + /* Connection establishment completed */
  11027. + lapc_debug(lapc, "established\n");
  11028. + lapc->lc->elapc = NULL;
  11029. + del_timer_sync(&lapc->timer);
  11030. + dect_lapc_state_change(lapc, DECT_SK_ESTABLISHED);
  11031. + }
  11032. +
  11033. + dect_lapc_send_iframe(lapc, pf);
  11034. + break;
  11035. + case DECT_FA_CTRL_S_CR_RNR:
  11036. + /*
  11037. + * Note peer receiver busy condition. If it was a RNR command
  11038. + * with the P bit set to 1, send a RR response with the F bit
  11039. + * set to 1. If it was a RNR response with the F bit set to 1,
  11040. + * clear timer recovery condition and update V(S).
  11041. + */
  11042. + lapc->peer_busy = true;
  11043. +
  11044. + if (fh->addr & DECT_FA_ADDR_CR_FLAG && pf)
  11045. + dect_lapc_send_sframe(lapc, DECT_FA_CTRL_S_CR_RR, true, true);
  11046. + else if (!(fh->addr & DECT_FA_ADDR_CR_FLAG) && pf) {
  11047. + del_timer_sync(&lapc->timer);
  11048. + lapc->v_s = n_r;
  11049. + }
  11050. +
  11051. + dect_lapc_update_ack(lapc, n_r);
  11052. + break;
  11053. + case DECT_FA_CTRL_S_CR_REJ:
  11054. + lapc->peer_busy = false;
  11055. + lapc->v_s = n_r;
  11056. + lapc->v_a = n_r;
  11057. + del_timer_sync(&lapc->timer);
  11058. + break;
  11059. + default:
  11060. + goto err;
  11061. + }
  11062. +
  11063. +err:
  11064. + kfree_skb(skb);
  11065. +}
  11066. +
  11067. +static void dect_lapc_rcv_uframe(struct dect_lapc *lapc, struct sk_buff *skb)
  11068. +{
  11069. + struct dect_fa_hdr *fh = (struct dect_fa_hdr *)skb->data;
  11070. + u8 pf, cr;
  11071. +
  11072. + pf = (fh->ctrl & DECT_FA_CTRL_U_PF_FLAG);
  11073. + cr = (fh->ctrl & DECT_FA_CTRL_U_U1_MASK) |
  11074. + (fh->ctrl & DECT_FA_CTRL_U_CR_MASK);
  11075. +
  11076. + /* unnumbered information is only valid in class U mode */
  11077. + if (cr == DECT_FA_CTRL_U_CR_UI) {
  11078. + if (lapc->dli.lln != DECT_LLN_CLASS_U)
  11079. + goto err;
  11080. + lapc_debug(lapc, "queue UI message: len: %u\n", skb->len);
  11081. + sock_queue_rcv_skb(lapc->sk, skb);
  11082. + return;
  11083. + }
  11084. +
  11085. + /* the remaining commands/responses are only valid in class B mode */
  11086. + if (lapc->dli.lln == DECT_LLN_CLASS_A)
  11087. + goto err;
  11088. +
  11089. + switch (cr) {
  11090. + case DECT_FA_CTRL_U_CR_SABM:
  11091. + break;
  11092. + case DECT_FA_CTRL_U_CR_DM:
  11093. + break;
  11094. + case DECT_FA_CTRL_U_CR_DISC:
  11095. + break;
  11096. + case DECT_FA_CTRL_U_CR_UA:
  11097. + break;
  11098. + }
  11099. +
  11100. +err:
  11101. + kfree_skb(skb);
  11102. +}
  11103. +
  11104. +static void dect_lapc_rcv(struct dect_lapc *lapc, struct sk_buff *skb)
  11105. +{
  11106. + struct dect_fa_hdr *fh = (struct dect_fa_hdr *)skb->data;
  11107. +
  11108. + if ((fh->ctrl & DECT_FA_CTRL_I_FMT_MASK) == DECT_FA_CTRL_I_FMT_ID)
  11109. + return dect_lapc_rcv_iframe(lapc, skb);
  11110. + else if ((fh->ctrl & DECT_FA_CTRL_S_FMT_MASK) == DECT_FA_CTRL_S_FMT_ID)
  11111. + return dect_lapc_rcv_sframe(lapc, skb);
  11112. + else if ((fh->ctrl & DECT_FA_CTRL_U_FMT_MASK) == DECT_FA_CTRL_U_FMT_ID)
  11113. + return dect_lapc_rcv_uframe(lapc, skb);
  11114. + else
  11115. + kfree_skb(skb);
  11116. +}
  11117. +
  11118. +int dect_lapc_transmit(struct dect_lapc *lapc)
  11119. +{
  11120. + dect_lapc_send_iframe(lapc, 0);
  11121. + return 0;
  11122. +}
  11123. +
  11124. +int dect_lapc_establish(struct dect_lapc *lapc)
  11125. +{
  11126. + struct sk_buff *skb;
  11127. +
  11128. + lapc_debug(lapc, "establish\n");
  11129. +
  11130. + /* Prepend zero-sized message to transmit queue to trigger connection
  11131. + * establishment.
  11132. + */
  11133. + skb = dect_lapc_alloc_skb(lapc);
  11134. + if (skb == NULL)
  11135. + return -ENOMEM;
  11136. + skb_queue_head(&lapc->sk->sk_write_queue, skb);
  11137. +
  11138. + lapc->lc->elapc = lapc;
  11139. + dect_lapc_send_iframe(lapc, lapc->dli.lln != DECT_LLN_CLASS_A);
  11140. + lapc->nlf = false;
  11141. +
  11142. + mod_timer(&lapc->timer, jiffies + DECT_LAPC_CLASS_A_ESTABLISH_TIMEOUT);
  11143. + return 0;
  11144. +}
  11145. +
  11146. +/*
  11147. + * Initiate link release.
  11148. + */
  11149. +void dect_lapc_release(struct dect_lapc *lapc, bool normal)
  11150. +{
  11151. + lapc_debug(lapc, "release: normal: %u\n", normal);
  11152. + if (dect_lapc_done(lapc) || !normal) {
  11153. + lapc->sk->sk_state = DECT_SK_RELEASED;
  11154. + dect_lapc_destroy(lapc);
  11155. + } else
  11156. + dect_lapc_state_change(lapc, DECT_SK_RELEASE_PENDING);
  11157. +}
  11158. +
  11159. +/*
  11160. + * Lc entity
  11161. + *
  11162. + * The Lc entity receives and transmits LAPC frames from/to the MAC layer.
  11163. + *
  11164. + * For transmission the frames are checksummed and fragmented into channel
  11165. + * sized units. The channel is chosen before transmission of a new frame
  11166. + * based on availability and demand. All fragments of one frame are
  11167. + * transmitted in the chosen channel.
  11168. + *
  11169. + * Received fragments are resegmented and have their checksum validated,
  11170. + * then routed to the LAPC entity associated with the logical link number.
  11171. + */
  11172. +
  11173. +#define lc_debug(lc, fmt, args...) \
  11174. + pr_debug("Lc (MCEI %u): " fmt, (lc)->mc->mcei, ## args)
  11175. +
  11176. +void dect_lc_destroy(struct dect_lc *lc)
  11177. +{
  11178. + lc_debug(lc, "destroy\n");
  11179. + dect_dlc_mac_conn_unbind(lc->mc);
  11180. + kfree_skb(lc->rx_head);
  11181. + kfree_skb(lc->tx_head);
  11182. + __skb_queue_purge(&lc->txq);
  11183. + kfree(lc);
  11184. +}
  11185. +
  11186. +static void dect_lc_put(struct dect_lc *lc)
  11187. +{
  11188. + if (--lc->use > 0)
  11189. + return;
  11190. + dect_lc_destroy(lc);
  11191. +}
  11192. +
  11193. +static void dect_lc_hold(struct dect_lc *lc)
  11194. +{
  11195. + lc->use++;
  11196. +}
  11197. +
  11198. +void dect_lc_unbind(struct dect_lc *lc, struct dect_lapc *lapc)
  11199. +{
  11200. + lc_debug(lc, "unbind LLN: %u use: %u\n", lapc->dli.lln, lc->use);
  11201. + if (WARN_ON(lc->lapcs[lapc->dli.lln] == NULL))
  11202. + return;
  11203. +
  11204. + lc->lapcs[lapc->dli.lln] = NULL;
  11205. + dect_lc_put(lc);
  11206. +}
  11207. +
  11208. +void dect_lc_bind(struct dect_lc *lc, struct dect_lapc *lapc)
  11209. +{
  11210. + lc_debug(lc, "bind LLN: %u use: %u\n", lapc->dli.lln, lc->use);
  11211. +
  11212. + lc->lapcs[lapc->dli.lln] = lapc;
  11213. + dect_lc_hold(lc);
  11214. +}
  11215. +
  11216. +struct dect_lc *dect_lc_init(struct dect_mac_conn *mc, gfp_t gfp)
  11217. +{
  11218. + struct dect_lc *lc;
  11219. +
  11220. + lc = kzalloc(sizeof(*lc), gfp);
  11221. + if (lc == NULL)
  11222. + return NULL;
  11223. +
  11224. + lc->mc = mc;
  11225. + dect_dlc_mac_conn_bind(mc);
  11226. +
  11227. + lc_debug(lc, "init\n");
  11228. + skb_queue_head_init(&lc->txq);
  11229. + switch (mc->mci.pmid.type) {
  11230. + case DECT_PMID_ASSIGNED:
  11231. + lc->lsig = dect_build_pmid(&mc->mci.pmid);
  11232. + break;
  11233. + default:
  11234. + lc->lsig = 0;
  11235. + break;
  11236. + }
  11237. +
  11238. + return lc;
  11239. +}
  11240. +
  11241. +static void dect_fa_frame_csum(const struct dect_lc *lc, struct sk_buff *skb)
  11242. +{
  11243. + u8 *data = skb->data;
  11244. + unsigned int i;
  11245. + u8 c0 = 0, c1 = 0;
  11246. + u8 x, y;
  11247. + u16 t;
  11248. +
  11249. + data[skb->len - 2] = 0;
  11250. + data[skb->len - 1] = 0;
  11251. +
  11252. + for (i = 0; i < skb->len; i++) {
  11253. + t = c0 + data[i];
  11254. + c0 = (t & 0xffU) + ((t >> 8) & 0x1U);
  11255. + t = c1 + c0;
  11256. + c1 = (t & 0xffU) + ((t >> 8) & 0x1U);
  11257. + }
  11258. +
  11259. + t = c0 + (u8)~c1;
  11260. + x = (t & 0xffU) + ((t >> 8) & 0x1U);
  11261. +
  11262. + t = (u8)~c0 + (u8)~c0;
  11263. + t = (t & 0xffU) + ((t >> 8) & 0x1U);
  11264. + t += c1;
  11265. + y = (t & 0xffU) + ((t >> 8) & 0x1U);
  11266. +
  11267. + data[skb->len - 2] = x ^ (lc->lsig >> 8);
  11268. + data[skb->len - 1] = y ^ (lc->lsig & 0xff);
  11269. + lc_debug(lc, "checksum: lsig: %.4x x: %.2x y: %.2x\n",
  11270. + lc->lsig, x, y);
  11271. +}
  11272. +
  11273. +static bool dect_fa_frame_csum_verify(const struct dect_lc *lc,
  11274. + struct sk_buff *skb)
  11275. +{
  11276. + u8 *data = skb->data;
  11277. + unsigned int i;
  11278. + u8 c0 = 0, c1 = 0;
  11279. + u16 t;
  11280. +
  11281. + data[skb->len - 2] ^= lc->lsig >> 8;
  11282. + data[skb->len - 1] ^= lc->lsig & 0xff;
  11283. +
  11284. + for (i = 0; i < skb->len; i++) {
  11285. + t = c0 + data[i];
  11286. + c0 = (t & 0xffU) + ((t >> 8) & 0x1U);
  11287. + t = c1 + c0;
  11288. + c1 = (t & 0xffU) + ((t >> 8) & 0x1U);
  11289. + }
  11290. +
  11291. + lc_debug(lc, "csum verify: lsig %.4x c0: %.2x c1: %.2x\n",
  11292. + lc->lsig, c0, c1);
  11293. + return c0 == (u8)~0 && c1 == (u8)~0;
  11294. +}
  11295. +
  11296. +static const u8 channel_sdu_size[] = {
  11297. + [DECT_MC_C_S] = DECT_C_S_SDU_SIZE,
  11298. + [DECT_MC_C_F] = DECT_C_F_SDU_SIZE,
  11299. +};
  11300. +
  11301. +/*
  11302. + * Prepare a DLC frame for transmission to the MAC layer. This involves
  11303. + * checksumming the frame, selecting the logical channel for transmission
  11304. + * and fragmenting it into units carried by the logical channel.
  11305. + */
  11306. +static struct sk_buff *dect_lc_tx(struct dect_lc *lc)
  11307. +{
  11308. + struct sk_buff *skb, *frag;
  11309. + u8 *fill, fill_len;
  11310. + u8 flen;
  11311. +
  11312. + skb = lc->tx_head;
  11313. + if (skb == NULL) {
  11314. + skb = skb_dequeue(&lc->txq);
  11315. + if (skb == NULL)
  11316. + return NULL;
  11317. + lc_debug(lc, "tx: begin new frame len: %u\n", skb->len);
  11318. +
  11319. + flen = channel_sdu_size[DECT_MC_C_S];
  11320. + fill_len = roundup(skb->len + DECT_FA_CSUM_SIZE, flen) -
  11321. + (skb->len + DECT_FA_CSUM_SIZE);
  11322. + fill = skb_put(skb, fill_len);
  11323. + memset(fill, DECT_FA_FILL_PATTERN, fill_len);
  11324. +
  11325. + skb_put(skb, DECT_FA_CSUM_SIZE);
  11326. + dect_fa_frame_csum(lc, skb);
  11327. +
  11328. + lc->tx_head = skb;
  11329. + lc->tx_len = flen;
  11330. + }
  11331. +
  11332. + /* Fragment into tx_len sized units */
  11333. + if (skb->len > lc->tx_len) {
  11334. + frag = skb_copy(skb, GFP_ATOMIC);
  11335. + if (frag == NULL)
  11336. + return NULL;
  11337. + skb_trim(frag, lc->tx_len);
  11338. + skb_pull(skb, lc->tx_len);
  11339. + } else {
  11340. + frag = lc->tx_head;
  11341. + lc->tx_head = NULL;
  11342. + }
  11343. +
  11344. + lc_debug(lc, "tx: %sfragment len: %u\n",
  11345. + lc->tx_head ? "" : "last ", frag->len);
  11346. + return frag;
  11347. +}
  11348. +
  11349. +static struct sk_buff *dect_lc_reassemble(struct dect_lc *lc,
  11350. + enum dect_data_channels chan,
  11351. + struct sk_buff *skb)
  11352. +{
  11353. + struct dect_fa_len fl;
  11354. + u8 flen, len;
  11355. +
  11356. + if (lc->rx_head == NULL) {
  11357. + dect_fa_parse_len(&fl, skb);
  11358. + len = fl.len;
  11359. + len += DECT_FA_HDR_SIZE + DECT_FA_CSUM_SIZE;
  11360. +
  11361. + flen = channel_sdu_size[chan];
  11362. + lc->rx_len = roundup(len, flen);
  11363. + lc_debug(lc, "new SDU: len: %u flen: %u\n", len, flen);
  11364. + }
  11365. +
  11366. + lc->rx_head = skb_append_frag(lc->rx_head, skb);
  11367. + skb = NULL;
  11368. +
  11369. + if (lc->rx_head->len >= lc->rx_len) {
  11370. + WARN_ON(lc->rx_head->len != lc->rx_len);
  11371. + skb = lc->rx_head;
  11372. + lc->rx_head = NULL;
  11373. +
  11374. + if (skb_linearize(skb) < 0)
  11375. + goto err;
  11376. + if (!dect_fa_frame_csum_verify(lc, skb))
  11377. + goto err;
  11378. +
  11379. + /* Trim checksum and filling */
  11380. + dect_fa_parse_len(&fl, skb);
  11381. + skb_trim(skb, fl.len + DECT_FA_HDR_SIZE);
  11382. + lc_debug(lc, "reassembled SDU: len: %u\n", skb->len);
  11383. + }
  11384. +
  11385. + return skb;
  11386. +
  11387. +err:
  11388. + lc_debug(lc, "reassembly failed\n");
  11389. + kfree_skb(skb);
  11390. + return NULL;
  11391. +}
  11392. +
  11393. +static void dect_lc_rcv(struct dect_lc *lc, enum dect_data_channels chan,
  11394. + struct sk_buff *skb)
  11395. +{
  11396. + struct dect_fa_hdr *fh;
  11397. + struct dect_lapc *lapc;
  11398. + struct dect_dli dli;
  11399. + enum dect_sapis sapi;
  11400. +
  11401. + skb = dect_lc_reassemble(lc, chan, skb);
  11402. + if (skb == NULL)
  11403. + return;
  11404. + fh = (struct dect_fa_hdr *)skb->data;
  11405. +
  11406. + dli.lln = (fh->addr & DECT_FA_ADDR_LLN_MASK) >> DECT_FA_ADDR_LLN_SHIFT;
  11407. + lc_debug(lc, "receive: LLN %u NLF %u SAPI %u\n",
  11408. + dli.lln, (fh->addr & DECT_FA_ADDR_NLF_FLAG) ? 1 : 0,
  11409. + (fh->addr & DECT_FA_ADDR_SAPI_MASK) >> DECT_FA_ADDR_SAPI_SHIFT);
  11410. +
  11411. + if (lc->lapcs[dli.lln] != NULL)
  11412. + return dect_lapc_rcv(lc->lapcs[dli.lln], skb);
  11413. +
  11414. + /* Link establishment: new requests are only valid while no link
  11415. + * establishment is in progress.
  11416. + */
  11417. + if (!(fh->addr & DECT_FA_ADDR_NLF_FLAG))
  11418. + goto err;
  11419. + if ((fh->ctrl & DECT_FA_CTRL_I_FMT_MASK) != DECT_FA_CTRL_I_FMT_ID)
  11420. + goto err;
  11421. + if (lc->elapc != NULL)
  11422. + goto err;
  11423. +
  11424. + sapi = (fh->addr & DECT_FA_ADDR_SAPI_MASK) >> DECT_FA_ADDR_SAPI_SHIFT;
  11425. + if (sapi != DECT_SAPI_CO_SIGNALLING && sapi != DECT_SAPI_CL_SIGNALLING)
  11426. + goto err;
  11427. + memcpy(&dli.mci, &lc->mc->mci, sizeof(dli.mci));
  11428. +
  11429. + lapc = dect_ssap_rcv_request(lc, &dli, sapi);
  11430. + if (lapc == NULL)
  11431. + goto err;
  11432. + dect_lc_bind(lc, lapc);
  11433. +
  11434. + return dect_lapc_rcv(lapc, skb);
  11435. +
  11436. +err:
  11437. + lc_debug(lc, "packet ignored\n");
  11438. + kfree_skb(skb);
  11439. +}
  11440. +
  11441. +void dect_cplane_rcv(struct dect_mac_conn *mc, enum dect_data_channels chan,
  11442. + struct sk_buff *skb)
  11443. +{
  11444. + struct dect_lc *lc;
  11445. +
  11446. + if (mc->lc == NULL) {
  11447. + lc = dect_lc_init(mc, GFP_ATOMIC);
  11448. + if (lc == NULL)
  11449. + goto err;
  11450. + mc->lc = lc;
  11451. + }
  11452. +
  11453. + lc_debug(mc->lc, "MAC_CO_DATA-ind: chan: %u len: %u\n", chan, skb->len);
  11454. + return dect_lc_rcv(mc->lc, chan, skb);
  11455. +
  11456. +err:
  11457. + kfree_skb(skb);
  11458. +}
  11459. +
  11460. +struct sk_buff *dect_cplane_dtr(struct dect_mac_conn *mc, enum dect_data_channels chan)
  11461. +{
  11462. + struct dect_lc *lc;
  11463. +
  11464. + lc = mc->lc;
  11465. + if (lc == NULL)
  11466. + return NULL;
  11467. + lc_debug(lc, "MAC_CO_DTR-ind: chan: %u\n", chan);
  11468. + return dect_lc_tx(lc);
  11469. +}
  11470. +
  11471. +void dect_cplane_notify_state_change(struct dect_mac_conn *mc)
  11472. +{
  11473. + struct dect_lc *lc = mc->lc;
  11474. + unsigned int i;
  11475. +
  11476. + if (lc == NULL)
  11477. + return;
  11478. +
  11479. + lc_debug(lc, "mac conn state change: state: %u\n", mc->state);
  11480. + switch (mc->state) {
  11481. + // FIXME: this does not make sense for incoming connections
  11482. + case DECT_MAC_CONN_OPEN_PENDING:
  11483. + break;
  11484. + case DECT_MAC_CONN_OPEN:
  11485. + for (i = 0; i < ARRAY_SIZE(lc->lapcs); i++) {
  11486. + if (lc->lapcs[i] == NULL)
  11487. + continue;
  11488. + dect_lapc_establish(lc->lapcs[i]);
  11489. + break;
  11490. + }
  11491. + break;
  11492. + case DECT_MAC_CONN_CLOSED:
  11493. + break;
  11494. + }
  11495. +}
  11496. +
  11497. +void dect_cplane_mac_dis_ind(const struct dect_mac_conn *mc,
  11498. + enum dect_release_reasons reason)
  11499. +{
  11500. + struct dect_lc *lc = mc->lc;
  11501. + unsigned int i;
  11502. + int err;
  11503. +
  11504. + if (lc == NULL)
  11505. + return;
  11506. +
  11507. + switch (reason) {
  11508. + case DECT_REASON_BEARER_RELEASE:
  11509. + err = 0;
  11510. + break;
  11511. + case DECT_REASON_BEARER_SETUP_OR_HANDOVER_FAILED:
  11512. + err = EHOSTUNREACH;
  11513. + break;
  11514. + case DECT_REASON_TIMEOUT_LOST_HANDSHAKE:
  11515. + err = ETIMEDOUT;
  11516. + break;
  11517. + default:
  11518. + err = EIO;
  11519. + break;
  11520. + }
  11521. +
  11522. + dect_lc_hold(lc);
  11523. + for (i = 0; i < ARRAY_SIZE(lc->lapcs); i++) {
  11524. + if (lc->lapcs[i] == NULL)
  11525. + continue;
  11526. + lc->lapcs[i]->sk->sk_state = DECT_SK_RELEASED;
  11527. + dect_lapc_error_report(lc->lapcs[i], err);
  11528. + dect_lapc_destroy(lc->lapcs[i]);
  11529. + }
  11530. + dect_lc_put(lc);
  11531. +}
  11532. +
  11533. +void dect_cplane_mac_enc_eks_ind(const struct dect_mac_conn *mc,
  11534. + enum dect_cipher_states status)
  11535. +{
  11536. + struct dect_lc *lc = mc->lc;
  11537. + struct dect_dl_encrypt enc;
  11538. + struct sk_buff *skb, *nskb;
  11539. + unsigned int i;
  11540. +
  11541. + if (lc == NULL || lc->use == 0)
  11542. + return;
  11543. +
  11544. + enc.status = status;
  11545. + skb = dect_alloc_notification(DECT_DL_ENCRYPT, &enc, sizeof(enc));
  11546. +
  11547. + for (i = 0; i < ARRAY_SIZE(lc->lapcs); i++) {
  11548. + if (lc->lapcs[i] == NULL)
  11549. + continue;
  11550. +
  11551. + nskb = skb ? skb_clone(skb, GFP_ATOMIC) : NULL;
  11552. + if (nskb != NULL)
  11553. + sock_queue_err_skb(lc->lapcs[i]->sk, nskb);
  11554. + else
  11555. + dect_lapc_error_report(lc->lapcs[i], ENOMEM);
  11556. + }
  11557. +
  11558. + kfree_skb(skb);
  11559. +}
  11560. diff --git a/net/dect/dlc_lu1_sap.c b/net/dect/dlc_lu1_sap.c
  11561. new file mode 100644
  11562. index 0000000..ff2b35e
  11563. --- /dev/null
  11564. +++ b/net/dect/dlc_lu1_sap.c
  11565. @@ -0,0 +1,475 @@
  11566. +/*
  11567. + * DECT DLC LU1 SAP sockets
  11568. + *
  11569. + * Copyright (c) 2009-2011 Patrick McHardy <[email protected]>
  11570. + *
  11571. + * This program is free software; you can redistribute it and/or modify
  11572. + * it under the terms of the GNU General Public License version 2 as
  11573. + * published by the Free Software Foundation.
  11574. + */
  11575. +
  11576. +#include <linux/kernel.h>
  11577. +#include <linux/module.h>
  11578. +#include <linux/init.h>
  11579. +#include <linux/socket.h>
  11580. +#include <linux/net.h>
  11581. +#include <linux/dect.h>
  11582. +#include <net/sock.h>
  11583. +#include <net/dect/dect.h>
  11584. +#include <net/dect/transceiver.h>
  11585. +
  11586. +#define DECT_LU1_FRAME_NONE 255
  11587. +#define DECT_LU1_PREQUEUE_LEN 5
  11588. +
  11589. +#define lu1_debug(lu1, fmt, args...) \
  11590. + pr_debug("LU1: rx_bytes: %u tx_bytes: %u " fmt, \
  11591. + (lu1)->qstats.rx_bytes, (lu1)->qstats.tx_bytes, \
  11592. + ## args)
  11593. +
  11594. +struct dect_lu1_sap {
  11595. + struct sock sk;
  11596. + int index;
  11597. + struct dect_ulei ulei;
  11598. + struct dect_mac_conn *mc;
  11599. + u8 frame;
  11600. + u8 slot;
  11601. + struct sk_buff *last;
  11602. + struct dect_lux lux;
  11603. + struct dect_lu1_queue_stats qstats;
  11604. +};
  11605. +
  11606. +/* Seamless handover slot offsets as per ETS 300 175-3 Annex F */
  11607. +static const u8 slot_offset_tbl[][DECT_HALF_FRAME_SIZE] = {
  11608. + [DECT_FULL_SLOT] = {
  11609. + [0] = 0,
  11610. + [1] = 1,
  11611. + [2] = 3,
  11612. + [3] = 5,
  11613. + [4] = 6,
  11614. + [5] = 8,
  11615. + [6] = 10,
  11616. + [7] = 11,
  11617. + [8] = 13,
  11618. + [9] = 15,
  11619. + [10] = 16,
  11620. + [11] = 18,
  11621. + },
  11622. + [DECT_DOUBLE_SLOT] = {
  11623. + [0] = 0,
  11624. + [2] = 8,
  11625. + [4] = 16,
  11626. + [6] = 24,
  11627. + [8] = 32,
  11628. + [10] = 40,
  11629. + },
  11630. + [DECT_LONG_SLOT_640] = {
  11631. + [0] = 0,
  11632. + [1] = 3,
  11633. + [2] = 6,
  11634. + [3] = 10,
  11635. + [4] = 13,
  11636. + [5] = 16,
  11637. + [6] = 20,
  11638. + [7] = 23,
  11639. + [8] = 26,
  11640. + [9] = 30,
  11641. + [10] = 33,
  11642. + },
  11643. +};
  11644. +
  11645. +static struct sk_buff *dect_lu1_dequeue(struct dect_lux *lux)
  11646. +{
  11647. + struct dect_lu1_sap *lu1 = container_of(lux, struct dect_lu1_sap, lux);
  11648. + struct dect_cluster *cl = lu1->mc->cl;
  11649. + struct sock *sk = &lu1->sk;
  11650. + struct sk_buff *skb, *clone, *head = NULL;
  11651. + u8 need = dect_b_field_size(lu1->mc->mcp.slot);
  11652. + u8 frame, slot, off, last_off;
  11653. +
  11654. + /* Fill queue up to prequeue len before delivering the first frame */
  11655. + if (lu1->frame == DECT_LU1_FRAME_NONE &&
  11656. + sk->sk_write_queue.qlen < DECT_LU1_PREQUEUE_LEN)
  11657. + return NULL;
  11658. +
  11659. + /* Calculate seamless handover data offset */
  11660. + frame = __dect_framenum(&cl->timer_base[DECT_TIMER_TX]);
  11661. + slot = __dect_slotnum(&cl->timer_base[DECT_TIMER_TX]);
  11662. + if (slot >= DECT_HALF_FRAME_SIZE)
  11663. + slot -= DECT_HALF_FRAME_SIZE;
  11664. +
  11665. + last_off = slot_offset_tbl[lu1->mc->mcp.slot][lu1->slot];
  11666. + off = slot_offset_tbl[lu1->mc->mcp.slot][slot];
  11667. +
  11668. + if (off > last_off)
  11669. + off -= last_off;
  11670. + else
  11671. + off += need - last_off;
  11672. +
  11673. + /* Advance queue */
  11674. + lu1_debug(lu1, "dequeue: slot: %u off: %u need: %u\n", slot, off, need);
  11675. + if (lu1->frame != DECT_LU1_FRAME_NONE && lu1->frame != frame)
  11676. + lu1->qstats.tx_bytes -= skb_queue_pull(&sk->sk_write_queue, off);
  11677. +
  11678. + lu1->frame = frame;
  11679. + lu1->slot = slot;
  11680. +
  11681. + /* Duplicate data from last frame on underflow */
  11682. + if (lu1->qstats.tx_bytes < need && lu1->last) {
  11683. + lu1->qstats.tx_underflow++;
  11684. + skb = skb_clone(lu1->last, GFP_ATOMIC);
  11685. + if (skb == NULL)
  11686. + goto err;
  11687. + skb_pull(skb, skb->len - (need - lu1->qstats.tx_bytes));
  11688. +
  11689. + skb_queue_head(&sk->sk_write_queue, skb);
  11690. + lu1->qstats.tx_bytes += skb->len;
  11691. + lu1_debug(lu1, "fill: len: %u need: %u\n", skb->len, need);
  11692. +
  11693. + }
  11694. +
  11695. + skb = NULL;
  11696. + while (need > 0) {
  11697. + if (skb == NULL) {
  11698. + skb = skb_peek(&sk->sk_write_queue);
  11699. + if (skb == NULL)
  11700. + goto underflow;
  11701. + /* The head needs to be copied to avoid sharing the
  11702. + * frag list. */
  11703. + clone = skb_copy(skb, GFP_ATOMIC);
  11704. + } else {
  11705. + if (skb_queue_is_last(&sk->sk_write_queue, skb))
  11706. + goto underflow;
  11707. + skb = skb->next;
  11708. + clone = skb_clone(skb, GFP_ATOMIC);
  11709. + }
  11710. +
  11711. + if (clone == NULL)
  11712. + goto err;
  11713. +
  11714. + if (clone->len > need)
  11715. + skb_trim(clone, need);
  11716. + need -= clone->len;
  11717. +
  11718. + head = skb_append_frag(head, clone);
  11719. + lu1_debug(lu1, "dequeue: head: %u need: %u\n", head->len, need);
  11720. + }
  11721. +
  11722. + if (skb_linearize(head) < 0)
  11723. + goto err;
  11724. +
  11725. + kfree_skb(lu1->last);
  11726. + lu1->last = skb_get(head);
  11727. +
  11728. + lu1_debug(lu1, "dequeued: len: %u\n", head->len);
  11729. + return head;
  11730. +
  11731. +underflow:
  11732. + lu1->qstats.tx_underflow++;
  11733. +err:
  11734. + kfree_skb(head);
  11735. + lu1_debug(lu1, "dequeue: no frame available\n");
  11736. + return NULL;
  11737. +}
  11738. +
  11739. +static void dect_lu1_enqueue(struct dect_lux *lux, struct sk_buff *skb)
  11740. +{
  11741. + struct dect_lu1_sap *lu1 = container_of(lux, struct dect_lu1_sap, lux);
  11742. + unsigned int len = skb->len;
  11743. +
  11744. + if (sock_queue_rcv_skb(&lu1->sk, skb) < 0)
  11745. + kfree_skb(skb);
  11746. + else
  11747. + lu1->qstats.rx_bytes += len;
  11748. +}
  11749. +
  11750. +static void dect_lu1_disconnect(struct dect_lux *lux)
  11751. +{
  11752. + struct dect_lu1_sap *lu1 = container_of(lux, struct dect_lu1_sap, lux);
  11753. + struct sock *sk = &lu1->sk;
  11754. +
  11755. + sk->sk_state = DECT_SK_RELEASED;
  11756. + sk->sk_err = ENETDOWN;
  11757. + if (!sock_flag(sk, SOCK_DEAD))
  11758. + sk->sk_error_report(sk);
  11759. + lu1->mc->fbx = NULL;
  11760. + dect_dlc_mac_conn_unbind(lu1->mc);
  11761. + lu1->mc = NULL;
  11762. +}
  11763. +
  11764. +static const struct dect_lux_ops dect_lu1_ops = {
  11765. + .dequeue = dect_lu1_dequeue,
  11766. + .enqueue = dect_lu1_enqueue,
  11767. + .disconnect = dect_lu1_disconnect,
  11768. +};
  11769. +
  11770. +static inline struct dect_lu1_sap *dect_lu1_sap(struct sock *sk)
  11771. +{
  11772. + return (struct dect_lu1_sap *)sk;
  11773. +}
  11774. +
  11775. +static int dect_parse_ulei(struct dect_ulei *ulei,
  11776. + const struct sockaddr_dect_lu *addr)
  11777. +{
  11778. + if (dect_parse_ari(&ulei->mci.ari, (u64)addr->dect_ari << 24) == 0)
  11779. + return -EINVAL;
  11780. + dect_parse_pmid(&ulei->mci.pmid, addr->dect_pmid);
  11781. + ulei->mci.lcn = addr->dect_lcn;
  11782. + return 0;
  11783. +}
  11784. +
  11785. +static void dect_build_ulei(struct sockaddr_dect_lu *addr,
  11786. + const struct dect_ulei *ulei)
  11787. +{
  11788. + addr->dect_family = AF_DECT;
  11789. + addr->dect_pmid = dect_build_pmid(&ulei->mci.pmid);
  11790. + addr->dect_lcn = ulei->mci.lcn;
  11791. +}
  11792. +
  11793. +static int dect_lu1_init(struct sock *sk)
  11794. +{
  11795. + struct dect_lu1_sap *lu1 = dect_lu1_sap(sk);
  11796. +
  11797. + sk->sk_state = DECT_SK_RELEASED;
  11798. + lu1->frame = DECT_LU1_FRAME_NONE;
  11799. + return 0;
  11800. +}
  11801. +
  11802. +static void dect_lu1_close(struct sock *sk, long timeout)
  11803. +{
  11804. + struct dect_lu1_sap *lu1 = dect_lu1_sap(sk);
  11805. +
  11806. + if (sk->sk_state == DECT_SK_ESTABLISHED) {
  11807. + lu1->mc->fbx = NULL;
  11808. + dect_dlc_mac_conn_unbind(lu1->mc);
  11809. + sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
  11810. + }
  11811. +
  11812. + __skb_queue_purge(&sk->sk_receive_queue);
  11813. + __skb_queue_purge(&sk->sk_write_queue);
  11814. + kfree_skb(lu1->last);
  11815. +
  11816. + sock_orphan(sk);
  11817. + sock_put(sk);
  11818. +}
  11819. +
  11820. +static int dect_lu1_getname(struct sock *sk, struct sockaddr *uaddr,
  11821. + int *len, int peer)
  11822. +{
  11823. + struct sockaddr_dect_lu *addr = (struct sockaddr_dect_lu *)uaddr;
  11824. + struct dect_lu1_sap *lu1 = dect_lu1_sap(sk);
  11825. +
  11826. + if (peer)
  11827. + return -EOPNOTSUPP;
  11828. +
  11829. + addr->dect_index = lu1->index;
  11830. + dect_build_ulei(addr, &lu1->ulei);
  11831. + *len = sizeof(*addr);
  11832. + return 0;
  11833. +}
  11834. +
  11835. +static int dect_lu1_connect(struct sock *sk, struct sockaddr *uaddr, int len)
  11836. +{
  11837. + struct sockaddr_dect_lu *addr = (struct sockaddr_dect_lu *)uaddr;
  11838. + struct dect_lu1_sap *lu1 = dect_lu1_sap(sk);
  11839. + struct dect_cluster *cl;
  11840. + struct dect_ulei ulei;
  11841. + struct dect_mac_conn *mc;
  11842. + int err;
  11843. +
  11844. + err = dect_parse_ulei(&ulei, addr);
  11845. + if (err < 0)
  11846. + goto err1;
  11847. +
  11848. + err = -ENODEV;
  11849. + cl = dect_cluster_get_by_index(addr->dect_index);
  11850. + if (cl == NULL)
  11851. + goto err1;
  11852. +
  11853. + err = -ENETDOWN;
  11854. + mc = dect_mac_conn_get_by_mci(cl, &ulei.mci);
  11855. + if (mc == NULL)
  11856. + goto err1;
  11857. + WARN_ON(mc->state == DECT_MAC_CONN_CLOSED);
  11858. +
  11859. + err = -EBUSY;
  11860. + if (mc->fbx != NULL)
  11861. + goto err1;
  11862. +
  11863. + memcpy(&lu1->ulei, &ulei, sizeof(lu1->ulei));
  11864. +
  11865. + sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
  11866. + sk->sk_state = DECT_SK_ESTABLISHED;
  11867. +
  11868. + lu1->lux.fbx.ops = &dect_fbn_ops;
  11869. + lu1->lux.ops = &dect_lu1_ops;
  11870. + lu1->mc = mc;
  11871. + mc->fbx = &lu1->lux.fbx;
  11872. + dect_dlc_mac_conn_bind(lu1->mc);
  11873. + pr_debug("LU1: bound to MCEI %u\n", mc->mcei);
  11874. + return 0;
  11875. +
  11876. +err1:
  11877. + return err;
  11878. +}
  11879. +
  11880. +static int dect_lu1_getsockopt(struct sock *sk, int level, int optname,
  11881. + char __user *optval, int __user *optlen)
  11882. +{
  11883. + struct dect_lu1_sap *lu1 = dect_lu1_sap(sk);
  11884. + int len;
  11885. +
  11886. + if (get_user(len, optlen))
  11887. + return -EFAULT;
  11888. + if (len < 0)
  11889. + return -EINVAL;
  11890. +
  11891. + switch (optname) {
  11892. + case DECT_LU1_QUEUE_STATS:
  11893. + if (len > sizeof(lu1->qstats))
  11894. + len = sizeof(lu1->qstats);
  11895. + if (put_user(len, optlen) ||
  11896. + copy_to_user(optval, &lu1->qstats, len))
  11897. + return -EFAULT;
  11898. + break;
  11899. + default:
  11900. + return -ENOPROTOOPT;
  11901. + }
  11902. +
  11903. + return 0;
  11904. +}
  11905. +
  11906. +static int dect_lu1_recvmsg(struct sock *sk,
  11907. + struct msghdr *msg, size_t len,
  11908. + int noblock, int flags, int *addr_len)
  11909. +{
  11910. + struct dect_lu1_sap *lu1 = dect_lu1_sap(sk);
  11911. + struct sk_buff *skb;
  11912. + size_t copied = 0, copy;
  11913. + long timeo;
  11914. + int err = 0;
  11915. +
  11916. + if (flags & (MSG_OOB | MSG_TRUNC))
  11917. + return -EOPNOTSUPP;
  11918. +
  11919. + lock_sock(sk);
  11920. +
  11921. + if (sk->sk_state != DECT_SK_ESTABLISHED) {
  11922. + err = -ENOTCONN;
  11923. + goto out;
  11924. + }
  11925. +
  11926. + timeo = sock_rcvtimeo(sk, noblock);
  11927. +
  11928. + while (copied < len) {
  11929. + skb = skb_peek(&sk->sk_receive_queue);
  11930. + if (skb != NULL)
  11931. + goto copy;
  11932. +
  11933. + if (!timeo) {
  11934. + err = -EAGAIN;
  11935. + break;
  11936. + }
  11937. +
  11938. + if (signal_pending(current)) {
  11939. + err = sock_intr_errno(timeo);
  11940. + break;
  11941. + }
  11942. +
  11943. + sk_wait_data(sk, &timeo, NULL);
  11944. + continue;
  11945. +
  11946. +copy:
  11947. + copy = len - copied;
  11948. + if (copy > skb->len)
  11949. + copy = skb->len;
  11950. +
  11951. + err = skb_copy_datagram_msg(skb, 0, msg, copy);
  11952. + if (err < 0)
  11953. + break;
  11954. + copied += copy;
  11955. +
  11956. + if (copy < skb->len) {
  11957. + __skb_pull(skb, copy);
  11958. + break;
  11959. + } else
  11960. + sk_eat_skb(sk, skb);
  11961. + }
  11962. +
  11963. +out:
  11964. + lu1->qstats.rx_bytes -= copied;
  11965. + if (copied < len)
  11966. + lu1->qstats.rx_underflow++;
  11967. +
  11968. + release_sock(sk);
  11969. + lu1_debug(lu1, "recvmsg: dequeued: %zu len: %zu\n", copied, len);
  11970. + return copied ? : err;
  11971. +}
  11972. +
  11973. +static int dect_lu1_sendmsg(struct sock *sk,
  11974. + struct msghdr *msg, size_t len)
  11975. +{
  11976. + struct dect_lu1_sap *lu1 = dect_lu1_sap(sk);
  11977. + struct sk_buff *skb;
  11978. + int err;
  11979. +
  11980. + if (msg->msg_flags & MSG_OOB)
  11981. + return -EOPNOTSUPP;
  11982. +
  11983. + if (sk->sk_state != DECT_SK_ESTABLISHED)
  11984. + return -ENOTCONN;
  11985. +
  11986. + skb = sock_alloc_send_skb(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
  11987. + if (skb == NULL)
  11988. + goto err1;
  11989. + err = memcpy_from_msg(skb_put(skb, len), msg, len);
  11990. + if (err < 0)
  11991. + goto err2;
  11992. +
  11993. + skb_queue_tail(&sk->sk_write_queue, skb);
  11994. + lu1->qstats.tx_bytes += len;
  11995. + lu1_debug(lu1, "sendmsg: queued: %zu\n", len);
  11996. + return len;
  11997. +
  11998. +err2:
  11999. + kfree_skb(skb);
  12000. +err1:
  12001. + return err;
  12002. +}
  12003. +
  12004. +static struct dect_proto dect_lu1_proto = {
  12005. + .type = SOCK_STREAM,
  12006. + .protocol = DECT_LU1_SAP,
  12007. + .capability = -1,
  12008. + .ops = &dect_stream_ops,
  12009. + .proto.name = "DECT_LU1_SAP",
  12010. + .proto.owner = THIS_MODULE,
  12011. + .proto.obj_size = sizeof(struct dect_lu1_sap),
  12012. + .proto.init = dect_lu1_init,
  12013. + .proto.close = dect_lu1_close,
  12014. + .proto.connect = dect_lu1_connect,
  12015. + .proto.getsockopt = dect_lu1_getsockopt,
  12016. + .proto.recvmsg = dect_lu1_recvmsg,
  12017. + .proto.sendmsg = dect_lu1_sendmsg,
  12018. + .getname = dect_lu1_getname,
  12019. +};
  12020. +
  12021. +static int __init dect_lu1_sap_module_init(void)
  12022. +{
  12023. + BUILD_BUG_ON(sizeof(struct sockaddr_dect_lu) >
  12024. + sizeof(struct sockaddr));
  12025. + return dect_proto_register(&dect_lu1_proto);
  12026. +}
  12027. +
  12028. +static void dect_lu1_sap_module_exit(void)
  12029. +{
  12030. + dect_proto_unregister(&dect_lu1_proto);
  12031. +}
  12032. +
  12033. +module_init(dect_lu1_sap_module_init);
  12034. +module_exit(dect_lu1_sap_module_exit);
  12035. +
  12036. +MODULE_AUTHOR("Patrick McHardy <[email protected]>");
  12037. +MODULE_DESCRIPTION("DECT DLC LU1 SAP sockets");
  12038. +MODULE_LICENSE("GPL");
  12039. +
  12040. +MODULE_ALIAS_NET_PF_PROTO(PF_DECT, DECT_LU1_SAP);
  12041. diff --git a/net/dect/dlc_s_sap.c b/net/dect/dlc_s_sap.c
  12042. new file mode 100644
  12043. index 0000000..a744344
  12044. --- /dev/null
  12045. +++ b/net/dect/dlc_s_sap.c
  12046. @@ -0,0 +1,728 @@
  12047. +/*
  12048. + * DECT DLC S SAP sockets - DLC C-plane data link service access
  12049. + *
  12050. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  12051. + *
  12052. + * This program is free software; you can redistribute it and/or modify
  12053. + * it under the terms of the GNU General Public License version 2 as
  12054. + * published by the Free Software Foundation.
  12055. + */
  12056. +
  12057. +#ifdef CONFIG_DECT_DEBUG
  12058. +#define DEBUG
  12059. +#endif
  12060. +
  12061. +#include <linux/kernel.h>
  12062. +#include <linux/module.h>
  12063. +#include <linux/init.h>
  12064. +#include <linux/socket.h>
  12065. +#include <linux/net.h>
  12066. +#include <linux/dect.h>
  12067. +#include <asm/uaccess.h>
  12068. +#include <net/sock.h>
  12069. +#include <net/dect/dect.h>
  12070. +
  12071. +static DEFINE_SPINLOCK(dect_ssap_lock);
  12072. +static HLIST_HEAD(dect_ssap_sockets);
  12073. +static HLIST_HEAD(dect_ssap_listeners);
  12074. +
  12075. +struct dect_ssap {
  12076. + struct dect_csk csk;
  12077. + int index;
  12078. + struct dect_dlei dlei;
  12079. + struct dect_lapc *lapc;
  12080. + struct dect_mac_conn_params mcp;
  12081. +};
  12082. +
  12083. +static inline struct dect_ssap *dect_ssap(struct sock *sk)
  12084. +{
  12085. + return (struct dect_ssap *)sk;
  12086. +}
  12087. +
  12088. +static int dect_parse_dlei(struct dect_dlei *dlei,
  12089. + const struct sockaddr_dect_ssap *addr)
  12090. +{
  12091. + if (dect_parse_ari(&dlei->mci.ari, (u64)addr->dect_ari << 24) == 0)
  12092. + return -EINVAL;
  12093. + dect_parse_pmid(&dlei->mci.pmid, addr->dect_pmid);
  12094. + dlei->mci.lcn = addr->dect_lcn;
  12095. +
  12096. + dlei->lln = addr->dect_lln;
  12097. + if (dlei->lln > DECT_LLN_UNASSIGNED &&
  12098. + dlei->lln != DECT_LLN_ANY)
  12099. + return -EINVAL;
  12100. +
  12101. + dlei->sapi = addr->dect_sapi;
  12102. + switch (dlei->sapi) {
  12103. + case DECT_SAPI_CO_SIGNALLING:
  12104. + case DECT_SAPI_CL_SIGNALLING:
  12105. + case DECT_SAPI_ANY:
  12106. + break;
  12107. + default:
  12108. + return -EINVAL;
  12109. + }
  12110. + return 0;
  12111. +}
  12112. +
  12113. +static void dect_build_dlei(struct sockaddr_dect_ssap *addr,
  12114. + const struct dect_dlei *dlei)
  12115. +{
  12116. + addr->dect_family = AF_DECT;
  12117. + addr->dect_pmid = dect_build_pmid(&dlei->mci.pmid);
  12118. + addr->dect_ari = dect_build_ari(&dlei->mci.ari) >> 24;
  12119. + addr->dect_lcn = dlei->mci.lcn;
  12120. + addr->dect_lln = dlei->lln;
  12121. + addr->dect_sapi = dlei->sapi;
  12122. +}
  12123. +
  12124. +static void dect_ssap_insert(struct sock *sk)
  12125. +{
  12126. + sk_add_node(sk, &dect_ssap_sockets);
  12127. + sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
  12128. +}
  12129. +
  12130. +static void dect_ssap_unlink(struct sock *sk)
  12131. +{
  12132. + if (sk_del_node_init(sk))
  12133. + sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
  12134. +}
  12135. +
  12136. +static int dect_ssap_init(struct sock *sk)
  12137. +{
  12138. + struct dect_ssap *ssap = dect_ssap(sk);
  12139. +
  12140. + INIT_HLIST_HEAD(&ssap->csk.accept_queue);
  12141. + return 0;
  12142. +}
  12143. +
  12144. +static struct sock *dect_ssap_acceptq_dequeue(struct dect_ssap *ssap)
  12145. +{
  12146. + struct sock *sk;
  12147. +
  12148. + if (hlist_empty(&ssap->csk.accept_queue))
  12149. + return NULL;
  12150. + sk = hlist_entry(ssap->csk.accept_queue.first, struct sock, sk_bind_node);
  12151. + __sk_del_bind_node(sk);
  12152. + sk_node_init(&sk->sk_bind_node);
  12153. + sk_acceptq_removed(&ssap->csk.sk);
  12154. + return sk;
  12155. +}
  12156. +
  12157. +static void dect_ssap_close(struct sock *sk, long timeout)
  12158. +{
  12159. + struct dect_ssap *ssap = dect_ssap(sk);
  12160. + struct sock *req;
  12161. +
  12162. + pr_debug("close sock %p refcnt %u rmem %u wmem %u\n",
  12163. + sk, atomic_read(&sk->sk_refcnt),
  12164. + atomic_read(&sk->sk_rmem_alloc),
  12165. + atomic_read(&sk->sk_wmem_alloc));
  12166. +
  12167. + spin_lock_bh(&dect_ssap_lock);
  12168. + dect_ssap_unlink(sk);
  12169. + spin_unlock_bh(&dect_ssap_lock);
  12170. +
  12171. + if (sk->sk_state != DECT_SK_RELEASED && ssap->lapc != NULL)
  12172. + dect_lapc_release(ssap->lapc, false);
  12173. +
  12174. + if (!hlist_unhashed(&sk->sk_bind_node))
  12175. + __sk_del_bind_node(sk);
  12176. +
  12177. + while ((req = dect_ssap_acceptq_dequeue(ssap)) != NULL) {
  12178. + spin_lock_bh(&dect_ssap_lock);
  12179. + dect_ssap_unlink(req);
  12180. + spin_unlock_bh(&dect_ssap_lock);
  12181. +
  12182. + dect_lapc_release(dect_ssap(req)->lapc, false);
  12183. + }
  12184. +
  12185. + sk_common_release(sk);
  12186. +}
  12187. +
  12188. +static int dect_ssap_bind_conflict(int index, const struct dect_dlei *dlei)
  12189. +{
  12190. + struct dect_ssap *ssap;
  12191. + struct sock *sk;
  12192. +
  12193. + // FIXME: wildcards
  12194. + sk_for_each(sk, &dect_ssap_sockets) {
  12195. + ssap = dect_ssap(sk);
  12196. + if (ssap->index == index &&
  12197. + !dect_ari_cmp(&ssap->dlei.mci.ari, &dlei->mci.ari) &&
  12198. + !dect_pmid_cmp(&ssap->dlei.mci.pmid, &dlei->mci.pmid) &&
  12199. + ssap->dlei.lln == dlei->lln &&
  12200. + ssap->dlei.sapi == dlei->sapi)
  12201. + return -EADDRINUSE;
  12202. + }
  12203. + return 0;
  12204. +}
  12205. +
  12206. +static int dect_ssap_bind(struct sock *sk, struct sockaddr *uaddr, int len)
  12207. +{
  12208. + struct sockaddr_dect_ssap *addr = (struct sockaddr_dect_ssap *)uaddr;
  12209. + struct dect_ssap *ssap = dect_ssap(sk);
  12210. + struct dect_dlei dlei;
  12211. + int err;
  12212. +
  12213. + if (len < sizeof(*addr) || addr->dect_family != AF_DECT)
  12214. + return -EINVAL;
  12215. +
  12216. + err = dect_parse_dlei(&dlei, addr);
  12217. + if (err < 0)
  12218. + return err;
  12219. +
  12220. + lock_sock(sk);
  12221. + spin_lock_bh(&dect_ssap_lock);
  12222. +
  12223. + err = dect_ssap_bind_conflict(addr->dect_index, &dlei);
  12224. + if (err < 0)
  12225. + goto out;
  12226. +
  12227. + ssap->index = addr->dect_index;
  12228. + memcpy(&ssap->dlei, &dlei, sizeof(ssap->dlei));
  12229. + dect_ssap_insert(sk);
  12230. +out:
  12231. + spin_unlock_bh(&dect_ssap_lock);
  12232. + release_sock(sk);
  12233. + return err;
  12234. +}
  12235. +
  12236. +static struct dect_ssap *dect_ssap_lookup_listener(const struct dect_cluster *cl,
  12237. + const struct dect_dli *dli,
  12238. + enum dect_sapis sapi)
  12239. +{
  12240. + struct dect_ssap *ssap;
  12241. + struct sock *sk;
  12242. +
  12243. + pr_debug("lookup listener: lln %u sapi %u\n", dli->lln, sapi);
  12244. + sk_for_each_bound(sk, &dect_ssap_listeners) {
  12245. + ssap = dect_ssap(sk);
  12246. + if (cl->index != ssap->index)
  12247. + continue;
  12248. +#if 0
  12249. + if (!dect_ari_cmp(&ssap->dlei.mci.ari, &dli->mci.ari))
  12250. + continue;
  12251. + if (!dect_pmid_cmp(&ssap->dlei.mci.pmid, &dli->mci.pmid))
  12252. + continue;
  12253. +#endif
  12254. + pr_debug("ssap: lln %u sapi %u\n", ssap->dlei.lln, ssap->dlei.sapi);
  12255. + if (ssap->dlei.lln != DECT_LLN_ANY &&
  12256. + ssap->dlei.lln != dli->lln)
  12257. + continue;
  12258. + if (ssap->dlei.sapi != DECT_SAPI_ANY &&
  12259. + ssap->dlei.sapi != sapi)
  12260. + continue;
  12261. + return ssap;
  12262. + }
  12263. + return NULL;
  12264. +}
  12265. +
  12266. +struct dect_lapc *dect_ssap_rcv_request(struct dect_lc *lc,
  12267. + const struct dect_dli *dli,
  12268. + enum dect_sapis sapi)
  12269. +{
  12270. + struct dect_ssap *ssap, *newssap;
  12271. + struct sock *sk, *newsk;
  12272. + struct dect_lapc *lapc = NULL;
  12273. +
  12274. + spin_lock(&dect_ssap_lock);
  12275. + ssap = dect_ssap_lookup_listener(lc->mc->cl, dli, sapi);
  12276. + if (ssap == NULL)
  12277. + goto out;
  12278. +
  12279. + sk = &ssap->csk.sk;
  12280. + if (sk_acceptq_is_full(sk))
  12281. + goto out;
  12282. +
  12283. + newsk = sk_alloc(&init_net, PF_DECT, GFP_ATOMIC, sk->sk_prot, 0);
  12284. + if (newsk == NULL)
  12285. + goto out;
  12286. +
  12287. + sock_init_data(NULL, newsk);
  12288. + newsk->sk_type = sk->sk_type;
  12289. + newsk->sk_protocol = sk->sk_protocol;
  12290. + newsk->sk_destruct = sk->sk_destruct;
  12291. +
  12292. + lapc = dect_lapc_init(newsk, dli, sapi, lc, GFP_ATOMIC);
  12293. + if (lapc == NULL)
  12294. + goto err1;
  12295. +
  12296. + newssap = dect_ssap(newsk);
  12297. + newssap->index = lc->mc->cl->index;
  12298. + memcpy(&newssap->dlei.mci, &dli->mci, sizeof(newssap->dlei.mci));
  12299. + newssap->dlei.lln = dli->lln;
  12300. + newssap->dlei.sapi = sapi;
  12301. + newssap->lapc = lapc;
  12302. +
  12303. + newsk->sk_state = DECT_SK_ESTABLISHED;
  12304. + dect_ssap_insert(newsk);
  12305. + sk_add_bind_node(newsk, &ssap->csk.accept_queue);
  12306. + sk_acceptq_added(sk);
  12307. +
  12308. + sk->sk_state_change(sk);
  12309. + sk->sk_data_ready(0);
  12310. +out:
  12311. + spin_unlock(&dect_ssap_lock);
  12312. + return lapc;
  12313. +
  12314. +err1:
  12315. + sk_free(newsk);
  12316. + goto out;
  12317. +}
  12318. +
  12319. +static int dect_ssap_hash(struct sock *sk)
  12320. +{
  12321. + sk->sk_state = DECT_SK_LISTEN;
  12322. +
  12323. + spin_lock_bh(&dect_ssap_lock);
  12324. + sk_add_bind_node(sk, &dect_ssap_listeners);
  12325. + spin_unlock_bh(&dect_ssap_lock);
  12326. + return 0;
  12327. +}
  12328. +
  12329. +static void dect_ssap_unhash(struct sock *sk)
  12330. +{
  12331. + if (sk_hashed(sk)) {
  12332. + spin_lock_bh(&dect_ssap_lock);
  12333. + __sk_del_bind_node(sk);
  12334. + spin_unlock_bh(&dect_ssap_lock);
  12335. + }
  12336. +}
  12337. +
  12338. +static int dect_ssap_wait_req(struct sock *sk, int noblock)
  12339. +{
  12340. + struct task_struct *tsk = current;
  12341. + struct dect_ssap *ssap = dect_ssap(sk);
  12342. + long timeo = sock_rcvtimeo(sk, noblock);
  12343. +
  12344. + for (;;) {
  12345. + DEFINE_WAIT(wait);
  12346. +
  12347. + if (sk->sk_state != DECT_SK_LISTEN)
  12348. + return -EINVAL;
  12349. + if (!hlist_empty(&ssap->csk.accept_queue))
  12350. + break;
  12351. + if (!timeo)
  12352. + return -EWOULDBLOCK;
  12353. + if (signal_pending(tsk))
  12354. + return sock_intr_errno(timeo);
  12355. +
  12356. + prepare_to_wait_exclusive(sk_sleep(sk), &wait,
  12357. + TASK_INTERRUPTIBLE);
  12358. + release_sock(sk);
  12359. + timeo = schedule_timeout(timeo);
  12360. + lock_sock(sk);
  12361. + finish_wait(sk_sleep(sk), &wait);
  12362. + }
  12363. + return 0;
  12364. +}
  12365. +
  12366. +static struct sock *dect_ssap_accept(struct sock *sk, int flags, int *errp)
  12367. +{
  12368. + struct dect_ssap *ssap = dect_ssap(sk);
  12369. + struct sock *newsk;
  12370. + int err;
  12371. +
  12372. + lock_sock(sk);
  12373. + err = dect_ssap_wait_req(sk, flags & O_NONBLOCK);
  12374. + if (err < 0)
  12375. + goto err;
  12376. +
  12377. + newsk = dect_ssap_acceptq_dequeue(ssap);
  12378. + release_sock(sk);
  12379. +
  12380. + *errp = 0;
  12381. + return newsk;
  12382. +
  12383. +err:
  12384. + release_sock(sk);
  12385. + *errp = err;
  12386. + return NULL;
  12387. +}
  12388. +
  12389. +static int dect_ssap_connect(struct sock *sk, struct sockaddr *uaddr, int len)
  12390. +{
  12391. + struct sockaddr_dect_ssap *addr = (struct sockaddr_dect_ssap *)uaddr;
  12392. + struct dect_ssap *ssap = dect_ssap(sk);
  12393. + struct dect_cluster *cl;
  12394. + struct dect_dlei dlei;
  12395. + struct dect_dli dli;
  12396. + struct dect_lapc *lapc;
  12397. + struct dect_lc *lc;
  12398. + struct dect_mac_conn *mc;
  12399. + bool new_mc = false, new_lc = false;
  12400. + int err;
  12401. +
  12402. + if (len < sizeof(*addr) || addr->dect_family != AF_DECT)
  12403. + return -EINVAL;
  12404. +
  12405. + err = dect_parse_dlei(&dlei, addr);
  12406. + if (err < 0)
  12407. + goto err1;
  12408. +
  12409. + err = -ENODEV;
  12410. + cl = dect_cluster_get_by_index(addr->dect_index);
  12411. + if (cl == NULL)
  12412. + goto err1;
  12413. +
  12414. + /* The assignable class B LLNs may only be used for connections
  12415. + * originating from a PT. The unassigned LLN may be used by an FT
  12416. + * to request class B operation. Class A and U may be used by both.
  12417. + */
  12418. + err = -EINVAL;
  12419. + switch (dlei.lln) {
  12420. + case DECT_LLN_ASSIGNABLE_MIN ... DECT_LLN_ASSIGNABLE_MAX:
  12421. + if (cl->mode != DECT_MODE_PP)
  12422. + goto err1;
  12423. + break;
  12424. + case DECT_LLN_UNASSIGNED:
  12425. + if (cl->mode != DECT_MODE_FP)
  12426. + goto err1;
  12427. + break;
  12428. + default:
  12429. + break;
  12430. + }
  12431. +
  12432. + /* Lookup MAC connection and initiate new one if necessary */
  12433. + err = -ENOMEM;
  12434. + mc = dect_mac_conn_get_by_mci(cl, &dlei.mci);
  12435. + if (mc == NULL) {
  12436. + mc = dect_mac_conn_init(cl, &dlei.mci, NULL);
  12437. + if (mc == NULL)
  12438. + goto err1;
  12439. + new_mc = true;
  12440. + lc = NULL;
  12441. + } else {
  12442. + WARN_ON(mc->state == DECT_MAC_CONN_CLOSED);
  12443. + lc = mc->lc;
  12444. + }
  12445. +
  12446. + /* Get Lc entity and verify LLN is available */
  12447. + if (lc == NULL) {
  12448. + lc = dect_lc_init(mc, GFP_KERNEL);
  12449. + if (lc == NULL)
  12450. + goto err2;
  12451. + mc->lc = lc;
  12452. + new_lc = true;
  12453. + } else {
  12454. + err = -EADDRINUSE;
  12455. + if (lc->lapcs[dlei.lln] != NULL)
  12456. + goto err2;
  12457. + }
  12458. +
  12459. + memcpy(&dli.mci, &dlei.mci, sizeof(dli.mci));
  12460. + dli.lln = dlei.lln;
  12461. +
  12462. + lapc = dect_lapc_init(sk, &dli, dlei.sapi, lc, GFP_KERNEL);
  12463. + if (lapc == NULL)
  12464. + goto err3;
  12465. + ssap->lapc = lapc;
  12466. +
  12467. + dect_lc_bind(lc, lapc);
  12468. +
  12469. + if (new_mc)
  12470. + err = dect_dlc_mac_conn_establish(mc, &ssap->mcp);
  12471. + else
  12472. + err = dect_lapc_establish(lapc);
  12473. +
  12474. + if (err < 0)
  12475. + goto err4;
  12476. +
  12477. + sk->sk_state = DECT_SK_ESTABLISH_PENDING;
  12478. + return 0;
  12479. +
  12480. +err4:
  12481. + dect_lapc_destroy(lapc);
  12482. + /* Both will be release by dect_lapc_destroy() */
  12483. + new_lc = false;
  12484. + new_mc = false;
  12485. +err3:
  12486. + if (new_lc)
  12487. + dect_lc_destroy(lc);
  12488. +err2:
  12489. + if (new_mc)
  12490. + dect_dlc_mac_conn_destroy(mc);
  12491. +err1:
  12492. + return err;
  12493. +}
  12494. +
  12495. +static int dect_ssap_getname(struct sock *sk, struct sockaddr *uaddr, int *len,
  12496. + int peer)
  12497. +{
  12498. + struct sockaddr_dect_ssap *addr = (struct sockaddr_dect_ssap *)uaddr;
  12499. + struct dect_ssap *ssap = dect_ssap(sk);
  12500. +
  12501. +#if 0
  12502. + if (peer)
  12503. + return -EOPNOTSUPP;
  12504. +#endif
  12505. + addr->dect_index = ssap->index;
  12506. + dect_build_dlei(addr, &ssap->dlei);
  12507. + *len = sizeof(*addr);
  12508. + return 0;
  12509. +}
  12510. +
  12511. +static void dect_ssap_shutdown(struct sock *sk, int how)
  12512. +{
  12513. + struct dect_ssap *ssap = dect_ssap(sk);
  12514. +
  12515. + if (!(how & SEND_SHUTDOWN))
  12516. + return;
  12517. +
  12518. + if (sk->sk_state == DECT_SK_ESTABLISHED)
  12519. + dect_lapc_release(ssap->lapc, true);
  12520. +}
  12521. +
  12522. +static int dect_ssap_setsockopt(struct sock *sk, int level, int optname,
  12523. + char __user *optval, unsigned int optlen)
  12524. +{
  12525. + struct dect_ssap *ssap = dect_ssap(sk);
  12526. + struct dect_mac_conn_params mcp;
  12527. + struct dect_dl_encrypt dle;
  12528. + int err;
  12529. + u64 ck;
  12530. +
  12531. + switch (optname) {
  12532. + case DECT_DL_MAC_CONN_PARAMS:
  12533. + if (optlen != sizeof(mcp))
  12534. + return -EINVAL;
  12535. + if (sk->sk_state != DECT_SK_RELEASED)
  12536. + return -EISCONN;
  12537. + if (copy_from_user(&mcp, optval, sizeof(mcp)))
  12538. + return -EFAULT;
  12539. +
  12540. + switch (mcp.service) {
  12541. + case DECT_SERVICE_IN_MIN_DELAY:
  12542. + case DECT_SERVICE_IPX_ENCODED_PROTECTED:
  12543. + case DECT_SERVICE_IN_NORMAL_DELAY:
  12544. + case DECT_SERVICE_UNKNOWN:
  12545. + case DECT_SERVICE_C_CHANNEL_ONLY:
  12546. + case DECT_SERVICE_IP_ERROR_DETECTION:
  12547. + case DECT_SERVICE_IPQ_ERROR_DETECTION:
  12548. + break;
  12549. + default:
  12550. + return -EINVAL;
  12551. + }
  12552. +
  12553. + switch (mcp.slot) {
  12554. + case DECT_FULL_SLOT:
  12555. + case DECT_HALF_SLOT:
  12556. + case DECT_DOUBLE_SLOT:
  12557. + case DECT_LONG_SLOT_640:
  12558. + case DECT_LONG_SLOT_672:
  12559. + break;
  12560. + default:
  12561. + return -EINVAL;
  12562. + }
  12563. +
  12564. + ssap->mcp = mcp;
  12565. + err = 0;
  12566. + break;
  12567. + case DECT_DL_ENC_KEY:
  12568. + if (optlen != sizeof(ck))
  12569. + return -EINVAL;
  12570. + if (sk->sk_state != DECT_SK_ESTABLISH_PENDING &&
  12571. + sk->sk_state != DECT_SK_ESTABLISHED)
  12572. + return -ENOTCONN;
  12573. + if (copy_from_user(&ck, optval, sizeof(ck)))
  12574. + return -EFAULT;
  12575. + err = dect_dlc_mac_conn_enc_key_req(ssap->lapc->lc->mc, ck);
  12576. + break;
  12577. + case DECT_DL_ENCRYPT:
  12578. + if (optlen != sizeof(dle))
  12579. + return -EINVAL;
  12580. + if (sk->sk_state != DECT_SK_ESTABLISHED)
  12581. + return -ENOTCONN;
  12582. + if (ssap->lapc->lc->mc->cl->mode != DECT_MODE_PP)
  12583. + return -EOPNOTSUPP;
  12584. + if (copy_from_user(&dle, optval, sizeof(dle)))
  12585. + return -EFAULT;
  12586. + err = dect_dlc_mac_conn_enc_eks_req(ssap->lapc->lc->mc,
  12587. + dle.status);
  12588. + break;
  12589. + default:
  12590. + err = -ENOPROTOOPT;
  12591. + }
  12592. + return err;
  12593. +}
  12594. +
  12595. +static int dect_ssap_getsockopt(struct sock *sk, int level, int optname,
  12596. + char __user *optval, int __user *optlen)
  12597. +{
  12598. + struct dect_ssap *ssap = dect_ssap(sk);
  12599. + struct dect_mac_conn_params *mcp;
  12600. + int len;
  12601. +
  12602. + if (get_user(len, optlen))
  12603. + return -EFAULT;
  12604. + if (len < 0)
  12605. + return -EINVAL;
  12606. +
  12607. + switch (optname) {
  12608. + case DECT_DL_MAC_CONN_PARAMS:
  12609. + if (sk->sk_state != DECT_SK_ESTABLISH_PENDING &&
  12610. + sk->sk_state != DECT_SK_ESTABLISHED)
  12611. + return -ENOTCONN;
  12612. +
  12613. + mcp = &ssap->lapc->lc->mc->mcp;
  12614. + len = min_t(unsigned int, len, sizeof(*mcp));
  12615. + if (copy_to_user(optval, mcp, len))
  12616. + return -EFAULT;
  12617. + break;
  12618. + default:
  12619. + return -ENOPROTOOPT;
  12620. + }
  12621. +
  12622. + if (put_user(len, optlen))
  12623. + return -EFAULT;
  12624. + return 0;
  12625. +}
  12626. +
  12627. +static int dect_ssap_recvmsg(struct sock *sk,
  12628. + struct msghdr *msg, size_t len,
  12629. + int noblock, int flags, int *addr_len)
  12630. +{
  12631. + struct sockaddr_dect *addr;
  12632. + struct sk_buff *skb, *eskb;
  12633. + size_t copied = 0;
  12634. + int err;
  12635. +
  12636. + if (flags & MSG_OOB)
  12637. + return -EOPNOTSUPP;
  12638. +
  12639. + eskb = skb_dequeue(&sk->sk_error_queue);
  12640. + skb = skb_recv_datagram(sk, flags, noblock, &err);
  12641. + if (skb == NULL) {
  12642. + if (eskb != NULL && err == -EAGAIN) {
  12643. + err = 0;
  12644. + goto out;
  12645. + }
  12646. + if (sk->sk_type == SOCK_SEQPACKET) {
  12647. + lock_sock(sk);
  12648. + if (sk->sk_state != DECT_SK_ESTABLISHED &&
  12649. + err == -EAGAIN)
  12650. + err = -ENOTCONN;
  12651. + release_sock(sk);
  12652. + }
  12653. + goto out;
  12654. + }
  12655. +
  12656. + copied = skb->len;
  12657. + if (len < copied) {
  12658. + msg->msg_flags |= MSG_TRUNC;
  12659. + copied = len;
  12660. + }
  12661. +
  12662. + err = skb_copy_datagram_msg(skb, 0, msg, copied);
  12663. + if (err < 0)
  12664. + goto out_free;
  12665. +
  12666. + if (msg->msg_name != NULL) {
  12667. + addr = (struct sockaddr_dect *)msg->msg_name;
  12668. + addr->dect_family = AF_DECT;
  12669. + addr->dect_index = DECT_SK_CB(skb)->index;
  12670. + msg->msg_namelen = sizeof(*addr);
  12671. + }
  12672. +
  12673. + sock_recv_timestamp(msg, sk, skb);
  12674. +
  12675. + if (flags & MSG_TRUNC)
  12676. + copied = skb->len;
  12677. +out_free:
  12678. + skb_free_datagram(sk, skb);
  12679. +out:
  12680. + if (eskb != NULL)
  12681. + put_cmsg(msg, SOL_DECT, DECT_NOTIFY_CB(eskb)->type,
  12682. + eskb->len, eskb->data);
  12683. + kfree_skb(eskb);
  12684. +
  12685. + return err ? : copied;
  12686. +}
  12687. +
  12688. +static int dect_ssap_sendmsg(struct sock *sk,
  12689. + struct msghdr *msg, size_t len)
  12690. +{
  12691. + struct dect_ssap *ssap = dect_ssap(sk);
  12692. + struct sk_buff *skb;
  12693. + long timeo;
  12694. + int err;
  12695. +
  12696. + if (msg->msg_flags & MSG_OOB)
  12697. + return -EOPNOTSUPP;
  12698. +
  12699. + if (len > DECT_FA_I_MAX)
  12700. + return -EMSGSIZE;
  12701. +
  12702. + lock_sock(sk);
  12703. + if (sk->sk_type == SOCK_SEQPACKET) {
  12704. + if (sk->sk_state != DECT_SK_ESTABLISHED) {
  12705. + timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
  12706. + err = sk_stream_wait_connect(sk, &timeo);
  12707. + if (err < 0)
  12708. + goto err1;
  12709. + }
  12710. + }
  12711. +
  12712. + err = -EPIPE;
  12713. + if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
  12714. + goto err1;
  12715. +
  12716. + skb = sock_alloc_send_skb(sk, len + 32, msg->msg_flags & MSG_DONTWAIT, &err);
  12717. + if (skb == NULL)
  12718. + goto err1;
  12719. + skb_reset_mac_header(skb);
  12720. + skb_reserve(skb, 16);
  12721. + err = memcpy_from_msg(skb_put(skb, len), msg, len);
  12722. + if (err < 0)
  12723. + goto err2;
  12724. +
  12725. + skb_queue_tail(&sk->sk_write_queue, skb);
  12726. + release_sock(sk);
  12727. +
  12728. + dect_lapc_transmit(ssap->lapc);
  12729. + return len;
  12730. +
  12731. +err2:
  12732. + kfree_skb(skb);
  12733. +err1:
  12734. + err = sk_stream_error(sk, msg->msg_flags, err);
  12735. + release_sock(sk);
  12736. + return err;
  12737. +}
  12738. +
  12739. +static struct dect_proto dect_ssap_proto __read_mostly = {
  12740. + .type = SOCK_SEQPACKET,
  12741. + .protocol = DECT_S_SAP,
  12742. + .capability = CAP_NET_RAW,
  12743. + .ops = &dect_stream_ops,
  12744. + .proto.name = "DECT_S_SAP",
  12745. + .proto.owner = THIS_MODULE,
  12746. + .proto.obj_size = sizeof(struct dect_ssap),
  12747. + .proto.init = dect_ssap_init,
  12748. + .proto.close = dect_ssap_close,
  12749. + .proto.bind = dect_ssap_bind,
  12750. + .proto.hash = dect_ssap_hash,
  12751. + .proto.unhash = dect_ssap_unhash,
  12752. + .proto.accept = dect_ssap_accept,
  12753. + .proto.connect = dect_ssap_connect,
  12754. + .proto.shutdown = dect_ssap_shutdown,
  12755. + .proto.setsockopt = dect_ssap_setsockopt,
  12756. + .proto.getsockopt = dect_ssap_getsockopt,
  12757. + .proto.recvmsg = dect_ssap_recvmsg,
  12758. + .proto.sendmsg = dect_ssap_sendmsg,
  12759. + .getname = dect_ssap_getname,
  12760. +};
  12761. +
  12762. +int __init dect_ssap_module_init(void)
  12763. +{
  12764. + BUILD_BUG_ON(sizeof(struct sockaddr_dect_ssap) >
  12765. + sizeof(struct sockaddr));
  12766. + return dect_proto_register(&dect_ssap_proto);
  12767. +}
  12768. +
  12769. +void dect_ssap_module_exit(void)
  12770. +{
  12771. + dect_proto_unregister(&dect_ssap_proto);
  12772. +}
  12773. +
  12774. +MODULE_ALIAS_NET_PF_PROTO(PF_DECT, DECT_S_SAP);
  12775. diff --git a/net/dect/dlc_uplane.c b/net/dect/dlc_uplane.c
  12776. new file mode 100644
  12777. index 0000000..6d8d318
  12778. --- /dev/null
  12779. +++ b/net/dect/dlc_uplane.c
  12780. @@ -0,0 +1,86 @@
  12781. +/*
  12782. + * DECT DLC U-plane
  12783. + *
  12784. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  12785. + *
  12786. + * This program is free software; you can redistribute it and/or modify
  12787. + * it under the terms of the GNU General Public License version 2 as
  12788. + * published by the Free Software Foundation.
  12789. + */
  12790. +
  12791. +#ifdef CONFIG_DECT_DEBUG
  12792. +#define DEBUG
  12793. +#endif
  12794. +
  12795. +#include <linux/kernel.h>
  12796. +#include <linux/module.h>
  12797. +#include <linux/init.h>
  12798. +#include <linux/list.h>
  12799. +#include <linux/skbuff.h>
  12800. +#include <linux/net.h>
  12801. +#include <linux/dect.h>
  12802. +#include <net/dect/dect.h>
  12803. +
  12804. +static struct sk_buff *dect_fbn_dequeue(struct dect_fbx *fbx)
  12805. +{
  12806. + struct dect_lux *lux = container_of(fbx, struct dect_lux, fbx);
  12807. +
  12808. + return lux->ops->dequeue(lux);
  12809. +}
  12810. +
  12811. +static void dect_fbn_enqueue(struct dect_fbx *fbx, struct sk_buff *skb)
  12812. +{
  12813. + struct dect_lux *lux = container_of(fbx, struct dect_lux, fbx);
  12814. +
  12815. + lux->ops->enqueue(lux, skb);
  12816. +}
  12817. +
  12818. +const struct dect_fbx_ops dect_fbn_ops = {
  12819. + .dequeue = dect_fbn_dequeue,
  12820. + .enqueue = dect_fbn_enqueue,
  12821. +};
  12822. +EXPORT_SYMBOL_GPL(dect_fbn_ops);
  12823. +
  12824. +struct sk_buff *dect_uplane_dtr(struct dect_mac_conn *mc, enum dect_data_channels chan)
  12825. +{
  12826. + struct dect_fbx *fbx;
  12827. +
  12828. + fbx = mc->fbx;
  12829. + if (fbx == NULL)
  12830. + return NULL;
  12831. + return fbx->ops->dequeue(fbx);
  12832. +}
  12833. +
  12834. +void dect_uplane_rcv(struct dect_mac_conn *mc, enum dect_data_channels chan,
  12835. + struct sk_buff *skb)
  12836. +{
  12837. + struct dect_fbx *fbx;
  12838. +
  12839. + fbx = mc->fbx;
  12840. + if (fbx == NULL)
  12841. + goto err;
  12842. + return fbx->ops->enqueue(fbx, skb);
  12843. +
  12844. +err:
  12845. + kfree_skb(skb);
  12846. +}
  12847. +
  12848. +void dect_uplane_notify_state_change(struct dect_mac_conn *mc)
  12849. +{
  12850. + struct dect_lux *lux;
  12851. + struct dect_fbx *fbx;
  12852. +
  12853. + fbx = mc->fbx;
  12854. + if (fbx == NULL)
  12855. + return;
  12856. + lux = container_of(fbx, struct dect_lux, fbx);
  12857. +
  12858. + switch (mc->state) {
  12859. + case DECT_MAC_CONN_OPEN_PENDING:
  12860. + break;
  12861. + case DECT_MAC_CONN_OPEN:
  12862. + break;
  12863. + case DECT_MAC_CONN_CLOSED:
  12864. + return lux->ops->disconnect(lux);
  12865. + }
  12866. +}
  12867. diff --git a/net/dect/dsc.c b/net/dect/dsc.c
  12868. new file mode 100644
  12869. index 0000000..d3f597a
  12870. --- /dev/null
  12871. +++ b/net/dect/dsc.c
  12872. @@ -0,0 +1,141 @@
  12873. +/*
  12874. + * DECT Standard Cipher
  12875. + *
  12876. + * Copyright (c) 2010 Erik Tews <[email protected]>
  12877. + *
  12878. + * This program is free software; you can redistribute it and/or modify
  12879. + * it under the terms of the GNU General Public License version 2 as
  12880. + * published by the Free Software Foundation.
  12881. + */
  12882. +
  12883. +#include <linux/kernel.h>
  12884. +#include <linux/string.h>
  12885. +#include <net/dect/dsc.h>
  12886. +
  12887. +#define R1_LEN 17
  12888. +#define R2_LEN 19
  12889. +#define R3_LEN 21
  12890. +#define R4_LEN 23
  12891. +
  12892. +#define MASK_R1 (65536 | 32)
  12893. +#define MASK_R2 (262144 | 4096 | 8 | 4)
  12894. +#define MASK_R3 (1048576 | 2)
  12895. +#define MASK_R4 (256 | 4194304)
  12896. +
  12897. +#define R1_CLOCKMASK (1 << 8)
  12898. +#define R2_CLOCKMASK (1 << 9)
  12899. +#define R3_CLOCKMASK (1 << 10)
  12900. +
  12901. +#define R1_R4_CLOCKMASK (1 << 0)
  12902. +#define R2_R4_CLOCKMASK (1 << 1)
  12903. +#define R3_R4_CLOCKMASK (1 << 2)
  12904. +
  12905. +static uint32_t clock(uint32_t lfsr, int length, uint32_t mask)
  12906. +{
  12907. + return (lfsr >> 1) ^ (-(lfsr & 1) & mask);
  12908. +}
  12909. +
  12910. +static uint32_t combine(uint32_t comb, uint32_t r1, uint32_t r2, uint32_t r3)
  12911. +{
  12912. + uint32_t c, x10, x11, x20, x21, x30, x31;
  12913. +
  12914. + c = comb;
  12915. + x10 = r1 & 1;
  12916. + x11 = (r1 >> 1) & 1;
  12917. + x20 = r2 & 1;
  12918. + x21 = (r2 >> 1) & 1;
  12919. + x30 = r3 & 1;
  12920. + x31 = (r3 >> 1) & 1;
  12921. +
  12922. + return (x11 & x10 & c) ^
  12923. + (x20 & x11 & x10) ^
  12924. + (x21 & x10 & c) ^
  12925. + (x21 & x20 & x10) ^
  12926. + (x30 & x10 & c) ^
  12927. + (x30 & x20 & x10) ^
  12928. + (x11 & c) ^
  12929. + (x11 & x10) ^
  12930. + (x20 & x11) ^
  12931. + (x30 & c) ^
  12932. + (x31 & c) ^
  12933. + (x31 & x10) ^
  12934. + (x21) ^
  12935. + (x31);
  12936. +}
  12937. +
  12938. +void dect_dsc_keystream(uint64_t iv, const uint8_t *key,
  12939. + uint8_t *output, unsigned int len)
  12940. +{
  12941. + uint8_t input[16];
  12942. + uint32_t R1, R2, R3, R4, N1, N2, N3, COMB;
  12943. + unsigned int i, keybit;
  12944. +
  12945. + memset(output, 0, len);
  12946. + input[0] = iv & 0xff;
  12947. + input[1] = (iv >> 8) & 0xff;
  12948. + input[2] = (iv >> 16) & 0xff;
  12949. + input[3] = (iv >> 24) & 0xff;
  12950. + input[4] = (iv >> 32) & 0xff;
  12951. + for (i = 5; i < 8; i++)
  12952. + input[i] = 0;
  12953. + for (i = 0; i < 8; i++)
  12954. + input[i + 8] = key[i];
  12955. +
  12956. + R1 = R2 = R3 = R4 = COMB = 0;
  12957. +
  12958. + /* load IV and KEY */
  12959. + for (i = 0; i < 128; i++) {
  12960. + keybit = (input[i / 8] >> ((i) & 7)) & 1;
  12961. + R1 = clock(R1, R1_LEN, MASK_R1) ^ (keybit << (R1_LEN - 1));
  12962. + R2 = clock(R2, R2_LEN, MASK_R2) ^ (keybit << (R2_LEN - 1));
  12963. + R3 = clock(R3, R3_LEN, MASK_R3) ^ (keybit << (R3_LEN - 1));
  12964. + R4 = clock(R4, R4_LEN, MASK_R4) ^ (keybit << (R4_LEN - 1));
  12965. + }
  12966. +
  12967. + for (i = 0; i < 40 + (len * 8); i++) {
  12968. + N1 = R1;
  12969. + N2 = R2;
  12970. + N3 = R3;
  12971. + COMB = combine(COMB, R1, R2, R3);
  12972. + if (((R2 & R2_CLOCKMASK) != 0) ^
  12973. + ((R3 & R3_CLOCKMASK) != 0) ^
  12974. + ((R4 & R1_R4_CLOCKMASK) != 0))
  12975. + N1 = clock(R1, R1_LEN, MASK_R1);
  12976. + if (((R1 & R1_CLOCKMASK) != 0) ^
  12977. + ((R3 & R3_CLOCKMASK) != 0) ^
  12978. + ((R4 & R2_R4_CLOCKMASK) != 0))
  12979. + N2 = clock(R2, R2_LEN, MASK_R2);
  12980. + if (((R1 & R1_CLOCKMASK) != 0) ^
  12981. + ((R2 & R2_CLOCKMASK) != 0) ^
  12982. + ((R4 & R3_R4_CLOCKMASK) != 0))
  12983. + N3 = clock(R3, R3_LEN, MASK_R3);
  12984. +
  12985. + /* Check whether any registers are zero after 11 pre-ciphering
  12986. + * steps. If a register is all-zero after 11 steps, set input
  12987. + * bit to one (see U.S. patent 5608802)
  12988. + */
  12989. + if (i == 11) {
  12990. + if (!R1)
  12991. + N1 ^= (1 << (R1_LEN - 1));
  12992. + if (!R2)
  12993. + N2 ^= (1 << (R2_LEN - 1));
  12994. + if (!R3)
  12995. + N3 ^= (1 << (R3_LEN - 1));
  12996. + if (!R4)
  12997. + R4 ^= (1 << (R4_LEN - 1));
  12998. + }
  12999. +
  13000. + N1 = clock(N1, R1_LEN, MASK_R1);
  13001. + R1 = clock(N1, R1_LEN, MASK_R1);
  13002. + N2 = clock(N2, R2_LEN, MASK_R2);
  13003. + R2 = clock(N2, R2_LEN, MASK_R2);
  13004. + N3 = clock(N3, R3_LEN, MASK_R3);
  13005. + R3 = clock(N3, R3_LEN, MASK_R3);
  13006. + R4 = clock(R4, R4_LEN, MASK_R4);
  13007. + R4 = clock(R4, R4_LEN, MASK_R4);
  13008. + R4 = clock(R4, R4_LEN, MASK_R4);
  13009. +
  13010. + if (i >= 40)
  13011. + output[(i - 40) / 8] |= ((COMB) << (7 - ((i - 40) & 7)));
  13012. + }
  13013. +}
  13014. diff --git a/net/dect/identities.c b/net/dect/identities.c
  13015. new file mode 100644
  13016. index 0000000..28fe80d
  13017. --- /dev/null
  13018. +++ b/net/dect/identities.c
  13019. @@ -0,0 +1,222 @@
  13020. +/*
  13021. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  13022. + *
  13023. + * This program is free software; you can redistribute it and/or modify
  13024. + * it under the terms of the GNU General Public License version 2 as
  13025. + * published by the Free Software Foundation.
  13026. + */
  13027. +
  13028. +#include <linux/kernel.h>
  13029. +#include <linux/export.h>
  13030. +#include <linux/dect.h>
  13031. +#include <net/dect/dect.h>
  13032. +
  13033. +bool dect_ari_masked_cmp(const struct dect_ari *a1, const struct dect_ari *a2,
  13034. + const struct dect_ari *m)
  13035. +{
  13036. + /* An empty class mask implies a wildcard for everything */
  13037. + if (!m->arc)
  13038. + return false;
  13039. + if (a1->arc != a2->arc)
  13040. + return true;
  13041. +
  13042. + if ((a1->fpn ^ a2->fpn) & m->fpn)
  13043. + return true;
  13044. +
  13045. + switch (a1->arc) {
  13046. + case DECT_ARC_A:
  13047. + return ((a1->emc ^ a2->emc) & m->emc);
  13048. + case DECT_ARC_B:
  13049. + return (((a1->eic ^ a2->eic) & m->eic) |
  13050. + ((a1->fps ^ a2->fps) & m->fps));
  13051. + case DECT_ARC_C:
  13052. + return (((a1->poc ^ a2->poc) & m->poc) |
  13053. + ((a1->fps ^ a2->fps) & m->fps));
  13054. + case DECT_ARC_D:
  13055. + return ((a1->gop ^ a2->gop) & m->gop);
  13056. + case DECT_ARC_E:
  13057. + return ((a1->fil ^ a2->fil) & m->fil);
  13058. + default:
  13059. + return true;
  13060. + }
  13061. +}
  13062. +EXPORT_SYMBOL_GPL(dect_ari_masked_cmp);;
  13063. +
  13064. +bool dect_ari_cmp(const struct dect_ari *a1, const struct dect_ari *a2)
  13065. +{
  13066. + static const struct dect_ari mask = {
  13067. + .arc = ~0,
  13068. + .fpn = ~0,
  13069. + .fps = ~0,
  13070. + { ~0 }
  13071. + };
  13072. + return dect_ari_masked_cmp(a1, a2, &mask);
  13073. +}
  13074. +EXPORT_SYMBOL_GPL(dect_ari_cmp);
  13075. +
  13076. +u8 dect_parse_ari(struct dect_ari *ari, u64 a)
  13077. +{
  13078. + ari->arc = (a & DECT_ARI_ARC_MASK) >> DECT_ARI_ARC_SHIFT;
  13079. + switch (ari->arc) {
  13080. + case DECT_ARC_A:
  13081. + ari->emc = (a & DECT_ARI_A_EMC_MASK) >> DECT_ARI_A_EMC_SHIFT;
  13082. + ari->fpn = (a & DECT_ARI_A_FPN_MASK) >> DECT_ARI_A_FPN_SHIFT;
  13083. + return DECT_ARC_A_LEN;
  13084. + case DECT_ARC_B:
  13085. + ari->eic = (a & DECT_ARI_B_EIC_MASK) >> DECT_ARI_B_EIC_SHIFT;
  13086. + ari->fpn = (a & DECT_ARI_B_FPN_MASK) >> DECT_ARI_B_FPN_SHIFT;
  13087. + ari->fps = (a & DECT_ARI_B_FPS_MASK) >> DECT_ARI_B_FPS_SHIFT;
  13088. + return DECT_ARC_B_LEN;
  13089. + case DECT_ARC_C:
  13090. + ari->poc = (a & DECT_ARI_C_POC_MASK) >> DECT_ARI_C_POC_SHIFT;
  13091. + ari->fpn = (a & DECT_ARI_C_FPN_MASK) >> DECT_ARI_C_FPN_SHIFT;
  13092. + ari->fps = (a & DECT_ARI_C_FPS_MASK) >> DECT_ARI_C_FPS_SHIFT;
  13093. + return DECT_ARC_C_LEN;
  13094. + case DECT_ARC_D:
  13095. + ari->gop = (a & DECT_ARI_D_GOP_MASK) >> DECT_ARI_D_GOP_SHIFT;
  13096. + ari->fpn = (a & DECT_ARI_D_FPN_MASK) >> DECT_ARI_D_FPN_SHIFT;
  13097. + return DECT_ARC_D_LEN;
  13098. + case DECT_ARC_E:
  13099. + ari->fil = (a & DECT_ARI_E_FIL_MASK) >> DECT_ARI_E_FIL_SHIFT;
  13100. + ari->fpn = (a & DECT_ARI_E_FPN_MASK) >> DECT_ARI_E_FPN_SHIFT;
  13101. + return DECT_ARC_E_LEN;
  13102. + default:
  13103. + return 0;
  13104. + }
  13105. +}
  13106. +EXPORT_SYMBOL_GPL(dect_parse_ari);
  13107. +
  13108. +u64 dect_build_ari(const struct dect_ari *ari)
  13109. +{
  13110. + u64 a = 0;
  13111. +
  13112. + a |= (u64)ari->arc << DECT_ARI_ARC_SHIFT;
  13113. + switch (ari->arc) {
  13114. + case DECT_ARC_A:
  13115. + a |= (u64)ari->emc << DECT_ARI_A_EMC_SHIFT;
  13116. + a |= (u64)ari->fpn << DECT_ARI_A_FPN_SHIFT;
  13117. + break;
  13118. + case DECT_ARC_B:
  13119. + a |= (u64)ari->eic << DECT_ARI_B_EIC_SHIFT;
  13120. + a |= (u64)ari->fpn << DECT_ARI_B_FPN_SHIFT;
  13121. + a |= (u64)ari->fps << DECT_ARI_B_FPS_SHIFT;
  13122. + break;
  13123. + case DECT_ARC_C:
  13124. + a |= (u64)ari->poc << DECT_ARI_C_POC_SHIFT;
  13125. + a |= (u64)ari->fpn << DECT_ARI_C_FPN_SHIFT;
  13126. + a |= (u64)ari->fps << DECT_ARI_C_FPS_SHIFT;
  13127. + break;
  13128. + case DECT_ARC_D:
  13129. + a |= (u64)ari->gop << DECT_ARI_D_GOP_SHIFT;
  13130. + a |= (u64)ari->fpn << DECT_ARI_D_FPN_SHIFT;
  13131. + break;
  13132. + case DECT_ARC_E:
  13133. + a |= (u64)ari->fil << DECT_ARI_E_FIL_SHIFT;
  13134. + a |= (u64)ari->fpn << DECT_ARI_E_FPN_SHIFT;
  13135. + break;
  13136. + }
  13137. + return a;
  13138. +}
  13139. +EXPORT_SYMBOL_GPL(dect_build_ari);
  13140. +
  13141. +u64 dect_build_rfpi(const struct dect_idi *idi)
  13142. +{
  13143. + u64 t = 0;
  13144. +
  13145. + t |= idi->e ? DECT_RFPI_E_FLAG : 0;
  13146. + t |= dect_build_ari(&idi->pari) >> DECT_RFPI_ARI_SHIFT;
  13147. + t |= (u64)idi->rpn << DECT_RFPI_RPN_SHIFT;
  13148. + return t;
  13149. +}
  13150. +EXPORT_SYMBOL_GPL(dect_build_rfpi);
  13151. +
  13152. +bool dect_rfpi_cmp(const struct dect_idi *i1, const struct dect_idi *i2)
  13153. +{
  13154. + return dect_ari_cmp(&i1->pari, &i2->pari) ||
  13155. + i1->rpn != i2->rpn ||
  13156. + i1->e != i2->e;
  13157. +}
  13158. +EXPORT_SYMBOL_GPL(dect_rfpi_cmp);
  13159. +
  13160. +u16 dect_build_fmid(const struct dect_idi *idi)
  13161. +{
  13162. + u64 rfpi;
  13163. +
  13164. + rfpi = dect_build_rfpi(idi);
  13165. + rfpi >>= (sizeof(rfpi) - DECT_NT_ID_RFPI_LEN - 1) * BITS_PER_BYTE;
  13166. + return rfpi & DECT_FMID_MASK;
  13167. +}
  13168. +EXPORT_SYMBOL_GPL(dect_build_fmid);
  13169. +
  13170. +/*
  13171. + * PMID (Portable MAC Identity)
  13172. + */
  13173. +
  13174. +void dect_parse_pmid(struct dect_pmid *pmid, u32 p)
  13175. +{
  13176. + if ((p & DECT_PMID_DEFAULT_ID_MASK) == DECT_PMID_DEFAULT_ID) {
  13177. + pmid->type = DECT_PMID_DEFAULT;
  13178. + pmid->num = p & DECT_PMID_DEFAULT_NUM_MASK;
  13179. + } else if ((p & DECT_PMID_EMERGENCY_ID_MASK) == DECT_PMID_EMERGENCY_ID) {
  13180. + pmid->type = DECT_PMID_EMERGENCY;
  13181. + pmid->tpui = p & DECT_PMID_EMERGENCY_TPUI_MASK;
  13182. + } else {
  13183. + pmid->type = DECT_PMID_ASSIGNED;
  13184. + pmid->tpui = p & DECT_PMID_ASSIGNED_TPUI_MASK;
  13185. + }
  13186. +}
  13187. +EXPORT_SYMBOL_GPL(dect_parse_pmid);
  13188. +
  13189. +u32 dect_build_pmid(const struct dect_pmid *pmid)
  13190. +{
  13191. + u32 p = 0;
  13192. +
  13193. + switch (pmid->type) {
  13194. + case DECT_PMID_DEFAULT:
  13195. + p |= DECT_PMID_DEFAULT_ID;
  13196. + p |= pmid->tpui;
  13197. + break;
  13198. + case DECT_PMID_EMERGENCY:
  13199. + p |= DECT_PMID_EMERGENCY_ID;
  13200. + p |= pmid->tpui;
  13201. + break;
  13202. + case DECT_PMID_ASSIGNED:
  13203. + p |= pmid->tpui;
  13204. + break;
  13205. + }
  13206. + return p;
  13207. +}
  13208. +EXPORT_SYMBOL_GPL(dect_build_pmid);
  13209. +
  13210. +bool dect_pmid_cmp(const struct dect_pmid *p1, const struct dect_pmid *p2)
  13211. +{
  13212. + return memcmp(p1, p2, sizeof(*p1));
  13213. +}
  13214. +EXPORT_SYMBOL(dect_pmid_cmp);
  13215. +
  13216. +/**
  13217. + * dect_parse_mci - Extract the MCI elements from a packed MCI in a
  13218. + * struct sockaddr_dect_lu
  13219. + *
  13220. + * The packed MCI is build from ARI + PMID + LCN
  13221. + */
  13222. +int dect_parse_mci(struct dect_mci *mci, u64 m)
  13223. +{
  13224. + u32 p;
  13225. + u8 len;
  13226. +
  13227. + len = dect_parse_ari(&mci->ari, m);
  13228. +
  13229. + len += DECT_PMID_SIZE;
  13230. + p = (m >> (sizeof(m) * BITS_PER_BYTE - len)) & DECT_PMID_MASK;
  13231. + dect_parse_pmid(&mci->pmid, p);
  13232. +
  13233. + len += DECT_ECN_SIZE;
  13234. + mci->lcn = (m >> (sizeof(m) * BITS_PER_BYTE - len)) & DECT_LCN_MASK;
  13235. + return 0;
  13236. +}
  13237. +
  13238. +u64 dect_build_mci(const struct dect_mci *mci)
  13239. +{
  13240. + return 0;
  13241. +}
  13242. diff --git a/net/dect/mac_ccf.c b/net/dect/mac_ccf.c
  13243. new file mode 100644
  13244. index 0000000..0532648
  13245. --- /dev/null
  13246. +++ b/net/dect/mac_ccf.c
  13247. @@ -0,0 +1,2104 @@
  13248. +/*
  13249. + * DECT MAC Cluster Control Functions
  13250. + *
  13251. + * Copyright (c) 2009-2011 Patrick McHardy <[email protected]>
  13252. + *
  13253. + * This program is free software; you can redistribute it and/or modify
  13254. + * it under the terms of the GNU General Public License version 2 as
  13255. + * published by the Free Software Foundation.
  13256. + */
  13257. +
  13258. +#ifdef CONFIG_DECT_DEBUG
  13259. +#define DEBUG
  13260. +#endif
  13261. +
  13262. +#include <linux/kernel.h>
  13263. +#include <linux/module.h>
  13264. +#include <linux/init.h>
  13265. +#include <linux/list.h>
  13266. +#include <linux/skbuff.h>
  13267. +#include <linux/net.h>
  13268. +#include <linux/dect.h>
  13269. +#include <net/dect/dect.h>
  13270. +#include <net/dect/mac_ccf.h>
  13271. +#include <net/dect/mac_csf.h>
  13272. +#include <net/dect/ccp.h>
  13273. +
  13274. +static void dect_llme_scan_result_notify(const struct dect_cluster *cl,
  13275. + const struct dect_scan_result *res);
  13276. +static void dect_llme_mac_info_ind(const struct dect_cluster *cl,
  13277. + const struct dect_idi *idi,
  13278. + const struct dect_si *si);
  13279. +
  13280. +u8 dect_b_field_size(enum dect_slot_types slot)
  13281. +{
  13282. + static const u8 b_field_size[] = {
  13283. + [DECT_FULL_SLOT] = 40,
  13284. + [DECT_DOUBLE_SLOT] = 100,
  13285. + [DECT_LONG_SLOT_640] = 80,
  13286. + };
  13287. + return b_field_size[slot];
  13288. +}
  13289. +EXPORT_SYMBOL_GPL(dect_b_field_size);
  13290. +
  13291. +static struct dect_cluster *dect_cluster_get_by_name(const struct nlattr *nla)
  13292. +{
  13293. + struct dect_cluster *cl;
  13294. +
  13295. + list_for_each_entry(cl, &dect_cluster_list, list) {
  13296. + if (!nla_strcmp(nla, cl->name))
  13297. + return cl;
  13298. + }
  13299. + return NULL;
  13300. +}
  13301. +
  13302. +static struct dect_cluster *dect_cluster(const struct dect_cluster_handle *clh)
  13303. +{
  13304. + return container_of(clh, struct dect_cluster, handle);
  13305. +}
  13306. +
  13307. +static struct dect_cell_handle *
  13308. +dect_cluster_get_cell_by_rpn(struct dect_cluster *cl, u8 rpn)
  13309. +{
  13310. + struct dect_cell_handle *ch;
  13311. +
  13312. + list_for_each_entry(ch, &cl->cells, list) {
  13313. + if (ch->rpn == rpn)
  13314. + return ch;
  13315. + }
  13316. + return NULL;
  13317. +}
  13318. +
  13319. +/*
  13320. + * MAC CCF layer timers
  13321. + */
  13322. +
  13323. +static u8 dect_framenum(const struct dect_cluster *cl, enum dect_timer_bases b)
  13324. +{
  13325. + return __dect_framenum(&cl->timer_base[b]);
  13326. +}
  13327. +
  13328. +static void dect_run_timers(struct dect_cluster *cl, enum dect_timer_bases b)
  13329. +{
  13330. + __dect_run_timers(cl->name, &cl->timer_base[b]);
  13331. +}
  13332. +
  13333. +static void dect_timer_base_update(struct dect_cluster *cl,
  13334. + enum dect_timer_bases base,
  13335. + u32 mfn, u8 framenum, u8 slot)
  13336. +{
  13337. + cl->timer_base[base].mfn = mfn;
  13338. + cl->timer_base[base].framenum = framenum;
  13339. + cl->timer_base[base].slot = slot;
  13340. +}
  13341. +
  13342. +static void dect_timer_add(struct dect_cluster *cl, struct dect_timer *timer,
  13343. + enum dect_timer_bases b, u32 frame, u8 slot)
  13344. +{
  13345. + timer->cluster = cl;
  13346. + __dect_timer_add(cl->name, &cl->timer_base[b], timer, frame, slot);
  13347. +}
  13348. +
  13349. +static void dect_timer_setup(struct dect_timer *timer,
  13350. + void (*func)(struct dect_cluster *, void *),
  13351. + void *data)
  13352. +{
  13353. + dect_timer_init(timer);
  13354. + timer->cb.cluster = func;
  13355. + timer->data = data;
  13356. +}
  13357. +
  13358. +static void dect_ccf_time_ind(struct dect_cluster_handle *clh,
  13359. + enum dect_timer_bases base,
  13360. + u32 mfn, u8 framenum, u8 slot)
  13361. +{
  13362. + struct dect_cluster *cl = dect_cluster(clh);
  13363. +
  13364. + if (base == DECT_TIMER_TX) {
  13365. + dect_timer_base_update(cl, base, mfn, framenum, slot);
  13366. + dect_run_timers(cl, base);
  13367. + } else {
  13368. + dect_run_timers(cl, base);
  13369. + dect_timer_base_update(cl, base, mfn, framenum, slot);
  13370. + }
  13371. +}
  13372. +
  13373. +static void dect_scan_report(const struct dect_cluster_handle *clh,
  13374. + const struct dect_scan_result *res)
  13375. +{
  13376. + struct dect_cluster *cl = dect_cluster(clh);
  13377. +
  13378. + dect_llme_scan_result_notify(cl, res);
  13379. +}
  13380. +
  13381. +static void dect_mac_info_ind(const struct dect_cluster_handle *clh,
  13382. + const struct dect_idi *idi,
  13383. + const struct dect_si *si)
  13384. +{
  13385. + struct dect_cluster *cl = dect_cluster(clh);
  13386. +
  13387. + pr_debug("cl %p: MAC_INFO-ind: rpn: %u\n", cl, idi->rpn);
  13388. + cl->si = *si;
  13389. + cl->rpn = idi->rpn;
  13390. +
  13391. + dect_llme_mac_info_ind(cl, idi, &cl->si);
  13392. +}
  13393. +
  13394. +/*
  13395. + * Broadcast message control
  13396. + */
  13397. +
  13398. +/**
  13399. + * dect_bmc_mac_page_req - queue one segment of B_S channel data
  13400. + *
  13401. + * @cl: DECT cluster
  13402. + * @skb: SDU
  13403. + */
  13404. +void dect_bmc_mac_page_req(struct dect_cluster *cl, struct sk_buff *skb)
  13405. +{
  13406. + const struct dect_cell_handle *ch, *prev = NULL;
  13407. + struct sk_buff *clone;
  13408. +
  13409. + BUG_ON(cl->mode != DECT_MODE_FP);
  13410. +
  13411. + list_for_each_entry(ch, &cl->cells, list) {
  13412. + if (prev != NULL) {
  13413. + clone = skb_clone(skb, GFP_ATOMIC);
  13414. + if (clone != NULL)
  13415. + prev->ops->page_req(prev, clone);
  13416. + }
  13417. + prev = ch;
  13418. + }
  13419. + if (prev != NULL)
  13420. + prev->ops->page_req(prev, skb);
  13421. +}
  13422. +
  13423. +static void dect_bmc_page_ind(const struct dect_cluster_handle *clh,
  13424. + struct sk_buff *skb)
  13425. +{
  13426. + struct dect_cluster *cl = dect_cluster(clh);
  13427. +
  13428. + return dect_mac_page_ind(cl, skb);
  13429. +}
  13430. +
  13431. +/*
  13432. + * Multi-Bearer Control
  13433. + */
  13434. +
  13435. +#define mbc_debug(mbc, fmt, args...) \
  13436. + pr_debug("MBC (MCEI %u/%s): " fmt, \
  13437. + (mbc)->id.mcei, dect_mbc_states[(mbc)->state], ## args);
  13438. +
  13439. +static const char * const dect_mbc_states[] = {
  13440. + [DECT_MBC_NONE] = "NONE",
  13441. + [DECT_MBC_INITIATED] = "INITIATED",
  13442. + [DECT_MBC_ESTABLISHED] = "ESTABLISHED",
  13443. + [DECT_MBC_RELEASED] = "RELEASED",
  13444. +};
  13445. +
  13446. +static void dect_mbc_hold(struct dect_mbc *mbc)
  13447. +{
  13448. + mbc->refcnt++;
  13449. +}
  13450. +
  13451. +static void dect_mbc_put(struct dect_mbc *mbc)
  13452. +{
  13453. + if (--mbc->refcnt > 0)
  13454. + return;
  13455. + kfree(mbc);
  13456. +}
  13457. +
  13458. +static struct dect_tb *dect_mbc_tb_get_by_tbei(const struct dect_mbc *mbc,
  13459. + const struct dect_tbc_id *id)
  13460. +{
  13461. + struct dect_tb *tb;
  13462. +
  13463. + list_for_each_entry(tb, &mbc->tbs, list) {
  13464. + if (tb->id.tbei == id->tbei)
  13465. + return tb;
  13466. + }
  13467. + return NULL;
  13468. +}
  13469. +
  13470. +static struct dect_mbc *dect_mbc_get_by_tbc_id(const struct dect_cluster *cl,
  13471. + const struct dect_tbc_id *id)
  13472. +{
  13473. + struct dect_mbc *mbc;
  13474. +
  13475. + list_for_each_entry(mbc, &cl->mbcs, list) {
  13476. + if (!memcmp(&mbc->id.ari, &id->ari, sizeof(id->ari)) &&
  13477. + !memcmp(&mbc->id.pmid, &id->pmid, sizeof(id->pmid)) &&
  13478. + mbc->id.ecn == id->ecn)
  13479. + return mbc;
  13480. + }
  13481. + return NULL;
  13482. +}
  13483. +
  13484. +static struct dect_mbc *dect_mbc_get_by_mcei(const struct dect_cluster *cl, u32 mcei)
  13485. +{
  13486. + struct dect_mbc *mbc;
  13487. +
  13488. + list_for_each_entry(mbc, &cl->mbcs, list) {
  13489. + if (mbc->id.mcei == mcei)
  13490. + return mbc;
  13491. + }
  13492. + return NULL;
  13493. +}
  13494. +
  13495. +u32 dect_mbc_alloc_mcei(struct dect_cluster *cl)
  13496. +{
  13497. + u32 mcei;
  13498. +
  13499. + while (1) {
  13500. + mcei = ++cl->mcei_rover;
  13501. + if (mcei == 0)
  13502. + continue;
  13503. + if (dect_mbc_get_by_mcei(cl, mcei))
  13504. + continue;
  13505. + return mcei;
  13506. + }
  13507. +}
  13508. +
  13509. +static bool dect_ct_tail_allowed(const struct dect_cluster *cl, u8 framenum)
  13510. +{
  13511. + if (cl->mode == DECT_MODE_FP)
  13512. + return (framenum & 0x1) == 0x1;
  13513. + else
  13514. + return (framenum & 0x1) == 0x0;
  13515. +}
  13516. +
  13517. +/*
  13518. + * MBC normal receive half frame timer:
  13519. + *
  13520. + * Deliver received data segments to the DLC at half frame boundaries.
  13521. + * Data is delivered for the following channels:
  13522. + *
  13523. + * - C_S after an ARQ window
  13524. + * - I_N normal delay
  13525. + *
  13526. + * Additionally in half frames that end an ARQ window, acknowledgment
  13527. + * of C_S segment reception of the preceeding transmit half frame is
  13528. + * verified.
  13529. + */
  13530. +static void dect_mbc_normal_rx_timer(struct dect_cluster *cl, void *data)
  13531. +{
  13532. + struct dect_mbc *mbc = data;
  13533. + struct dect_tb *tb;
  13534. + struct sk_buff *skb;
  13535. +
  13536. + mbc_debug(mbc, "Normal RX timer\n");
  13537. + dect_mbc_hold(mbc);
  13538. +
  13539. + if (mbc->cs_rx_skb != NULL) {
  13540. + skb = mbc->cs_rx_skb;
  13541. + mbc->cs_rx_skb = NULL;
  13542. + mbc->stats.cs_rx_bytes += skb->len;
  13543. + dect_mac_co_data_ind(cl, mbc->id.mcei, DECT_MC_C_S, skb);
  13544. +
  13545. + /* C-channel reception might trigger release of the MBC in case
  13546. + * it acknowledges the last outstanding LAPC I-frame. */
  13547. + if (mbc->state == DECT_MBC_RELEASED)
  13548. + goto out;
  13549. + }
  13550. +
  13551. + if (mbc->cs_tx_ok && mbc->cs_rx_ok) {
  13552. + mbc->stats.cs_tx_bytes += mbc->cs_tx_skb->len;
  13553. + kfree_skb(mbc->cs_tx_skb);
  13554. + mbc->cs_tx_skb = NULL;
  13555. + mbc->cs_tx_ok = false;
  13556. + }
  13557. + mbc->cs_rx_ok = false;
  13558. +
  13559. + list_for_each_entry(tb, &mbc->tbs, list) {
  13560. + if (tb->b_rx_skb == NULL)
  13561. + continue;
  13562. + skb = tb->b_rx_skb;
  13563. + tb->b_rx_skb = NULL;
  13564. + mbc->stats.i_rx_bytes += skb->len;
  13565. + dect_mac_co_data_ind(cl, mbc->id.mcei, DECT_MC_I_N, skb);
  13566. + }
  13567. +
  13568. + dect_timer_add(cl, &mbc->normal_rx_timer, DECT_TIMER_RX,
  13569. + 1, dect_normal_receive_end(cl->mode));
  13570. +out:
  13571. + dect_mbc_put(mbc);
  13572. +}
  13573. +
  13574. +/*
  13575. + * MBC slot based receive timer:
  13576. + *
  13577. + * Deliver received I_N minimal delay B-field segments to the DLC.
  13578. + */
  13579. +static void dect_mbc_slot_rx_timer(struct dect_cluster *cl, void *data)
  13580. +{
  13581. + struct dect_tb *tb = data;
  13582. + struct dect_mbc *mbc = tb->mbc;
  13583. + struct sk_buff *skb;
  13584. +
  13585. + mbc_debug(mbc, "Slot RX timer: TBEI: %u LBN: %u slot: %u\n",
  13586. + tb->id.tbei, tb->id.lbn, tb->rx_slot);
  13587. +
  13588. + if (tb->b_rx_skb != NULL) {
  13589. + skb = tb->b_rx_skb;
  13590. + tb->b_rx_skb = NULL;
  13591. + mbc->stats.i_rx_bytes += skb->len;
  13592. + dect_mac_co_data_ind(cl, mbc->id.mcei, DECT_MC_I_N, skb);
  13593. + }
  13594. +
  13595. + dect_timer_add(cl, &tb->slot_rx_timer, DECT_TIMER_RX, 1, tb->rx_slot);
  13596. +}
  13597. +
  13598. +/*
  13599. + * MBC normal transmit half frame timer:
  13600. + *
  13601. + * Request data from the DLC for the next frame. Data is requested for the
  13602. + * following channels:
  13603. + *
  13604. + * - C_S before an ARQ window starts
  13605. + * - I_N normal delay
  13606. + */
  13607. +static void dect_mbc_normal_tx_timer(struct dect_cluster *cl, void *data)
  13608. +{
  13609. + const struct dect_cell_handle *ch;
  13610. + struct dect_mbc *mbc = data;
  13611. + struct dect_tb *tb;
  13612. + struct sk_buff *skb;
  13613. +
  13614. + mbc_debug(mbc, "Normal TX timer\n");
  13615. +
  13616. + if (dect_ct_tail_allowed(cl, dect_framenum(cl, DECT_TIMER_TX))) {
  13617. + if (mbc->cs_tx_skb == NULL) {
  13618. + skb = dect_mac_co_dtr_ind(cl, mbc->id.mcei, DECT_MC_C_S);
  13619. + if (skb != NULL) {
  13620. + DECT_CS_CB(skb)->seq = mbc->cs_tx_seq;
  13621. + mbc->cs_tx_seq = !mbc->cs_tx_seq;
  13622. + mbc->cs_tx_skb = skb;
  13623. + }
  13624. + }
  13625. +
  13626. + if (mbc->cs_tx_skb != NULL) {
  13627. + list_for_each_entry(tb, &mbc->tbs, list) {
  13628. + skb = skb_clone(mbc->cs_tx_skb, GFP_ATOMIC);
  13629. + if (skb == NULL)
  13630. + continue;
  13631. + ch = tb->ch;
  13632. + ch->ops->tbc_data_req(ch, &tb->id, DECT_MC_C_S, skb);
  13633. + mbc->cs_tx_ok = true;
  13634. + }
  13635. + }
  13636. + }
  13637. +
  13638. + if (mbc->mcp.service != DECT_SERVICE_IN_MIN_DELAY) {
  13639. + list_for_each_entry(tb, &mbc->tbs, list) {
  13640. + ch = tb->ch;
  13641. + skb = dect_mac_co_dtr_ind(cl, mbc->id.mcei, DECT_MC_I_N);
  13642. + if (skb != NULL) {
  13643. + mbc->stats.i_tx_bytes += skb->len;
  13644. + ch->ops->tbc_data_req(ch, &tb->id, DECT_MC_I_N, skb);
  13645. + }
  13646. + }
  13647. + }
  13648. +
  13649. + dect_timer_add(cl, &mbc->normal_tx_timer, DECT_TIMER_TX,
  13650. + 1, dect_normal_transmit_base(cl->mode));
  13651. +}
  13652. +
  13653. +/*
  13654. + * MBC slot based transmit timer:
  13655. + *
  13656. + * Request data from the DLC for the I_N minimal delay channel.
  13657. + */
  13658. +static void dect_mbc_slot_tx_timer(struct dect_cluster *cl, void *data)
  13659. +{
  13660. + struct dect_tb *tb = data;
  13661. + struct dect_mbc *mbc = tb->mbc;
  13662. + const struct dect_cell_handle *ch = tb->ch;
  13663. + struct sk_buff *skb;
  13664. +
  13665. + mbc_debug(mbc, "Slot TX timer: TBEI: %u LBN: %u slot: %u\n",
  13666. + tb->id.tbei, tb->id.lbn, tb->tx_slot);
  13667. +
  13668. + skb = dect_mac_co_dtr_ind(cl, mbc->id.mcei, DECT_MC_I_N);
  13669. + if (skb != NULL) {
  13670. + mbc->stats.i_tx_bytes += skb->len;
  13671. + ch->ops->tbc_data_req(ch, &tb->id, DECT_MC_I_N, skb);
  13672. + }
  13673. + dect_timer_add(cl, &tb->slot_tx_timer, DECT_TIMER_TX, 1, tb->tx_slot);
  13674. +}
  13675. +
  13676. +static int dect_mbc_complete_setup(struct dect_cluster *cl, struct dect_mbc *mbc)
  13677. +{
  13678. + if (!del_timer(&mbc->timer))
  13679. + return 0;
  13680. +
  13681. + dect_timer_add(cl, &mbc->normal_rx_timer, DECT_TIMER_RX,
  13682. + 0, dect_normal_receive_end(cl->mode));
  13683. + dect_timer_add(cl, &mbc->normal_tx_timer, DECT_TIMER_TX,
  13684. + 0, dect_normal_transmit_base(cl->mode));
  13685. + mbc->state = DECT_MBC_ESTABLISHED;
  13686. +
  13687. + return 1;
  13688. +}
  13689. +
  13690. +static void dect_mbc_tb_release(struct dect_tb *tb);
  13691. +
  13692. +static void dect_mbc_tb_handover_timer(struct dect_cluster *cl, void *data)
  13693. +{
  13694. + struct dect_tb *tb = data, *tb1, *i;
  13695. + struct dect_mbc *mbc = tb->mbc;
  13696. +
  13697. + mbc_debug(mbc, "Handover timer: TBEI: %u LBN: %u\n",
  13698. + tb->id.tbei, tb->id.lbn);
  13699. +
  13700. + tb1 = NULL;
  13701. + list_for_each_entry(i, &mbc->tbs, list) {
  13702. + if (i->id.lbn == tb->id.lbn) {
  13703. + tb1 = i;
  13704. + break;
  13705. + }
  13706. + }
  13707. + if (tb1 == NULL)
  13708. + return;
  13709. +
  13710. + tb1->ch->ops->tbc_dis_req(tb1->ch, &tb1->id,
  13711. + DECT_REASON_BEARER_HANDOVER_COMPLETED);
  13712. + list_del(&tb1->list);
  13713. + dect_mbc_tb_release(tb1);
  13714. + mbc->stats.handovers++;
  13715. +}
  13716. +
  13717. +static void dect_mbc_tb_complete_setup(struct dect_cluster *cl, struct dect_tb *tb)
  13718. +{
  13719. + if (cl->mode == DECT_MODE_FP && tb->handover)
  13720. + dect_timer_add(cl, &tb->handover_timer, DECT_TIMER_RX,
  13721. + DECT_MBC_TB_HANDOVER_TIMEOUT, tb->rx_slot);
  13722. +
  13723. + if (tb->mbc->mcp.service == DECT_SERVICE_IN_MIN_DELAY) {
  13724. + dect_timer_add(cl, &tb->slot_rx_timer, DECT_TIMER_RX,
  13725. + 0, tb->rx_slot);
  13726. + dect_timer_add(cl, &tb->slot_tx_timer, DECT_TIMER_TX,
  13727. + 0, tb->tx_slot);
  13728. + }
  13729. +}
  13730. +
  13731. +static void dect_mbc_tb_release(struct dect_tb *tb)
  13732. +{
  13733. + dect_timer_del(&tb->handover_timer);
  13734. + dect_timer_del(&tb->slot_rx_timer);
  13735. + dect_timer_del(&tb->slot_tx_timer);
  13736. + kfree(tb);
  13737. +}
  13738. +
  13739. +static struct dect_tb *dect_mbc_tb_init(struct dect_mbc *mbc,
  13740. + const struct dect_cell_handle *ch, u8 lbn)
  13741. +{
  13742. + struct dect_tb *tb;
  13743. +
  13744. + tb = kzalloc(sizeof(*tb), GFP_ATOMIC);
  13745. + if (tb == NULL)
  13746. + return NULL;
  13747. +
  13748. + tb->mbc = mbc;
  13749. + tb->ch = ch;
  13750. + tb->id.ari = mbc->id.ari;
  13751. + tb->id.pmid = mbc->id.pmid;
  13752. + tb->id.ecn = 0;
  13753. + tb->id.lbn = lbn;
  13754. + tb->id.tbei = 0;
  13755. + tb->handover = false;
  13756. + tb->rx_slot = 0;
  13757. + tb->tx_slot = 0;
  13758. +
  13759. + dect_timer_setup(&tb->handover_timer, dect_mbc_tb_handover_timer, tb);
  13760. + dect_timer_setup(&tb->slot_rx_timer, dect_mbc_slot_rx_timer, tb);
  13761. + dect_timer_setup(&tb->slot_tx_timer, dect_mbc_slot_tx_timer, tb);
  13762. +
  13763. + return tb;
  13764. +}
  13765. +
  13766. +static void dect_mbc_release(struct dect_mbc *mbc)
  13767. +{
  13768. + struct dect_tb *tb, *next;
  13769. +
  13770. + mbc_debug(mbc, "release\n");
  13771. + mbc->state = DECT_MBC_RELEASED;
  13772. + del_timer(&mbc->timer);
  13773. + list_del(&mbc->list);
  13774. +
  13775. + dect_timer_del(&mbc->normal_rx_timer);
  13776. + dect_timer_del(&mbc->normal_tx_timer);
  13777. +
  13778. + list_for_each_entry_safe(tb, next, &mbc->tbs, list)
  13779. + dect_mbc_tb_release(tb);
  13780. +
  13781. + kfree_skb(mbc->cs_rx_skb);
  13782. + kfree_skb(mbc->cs_tx_skb);
  13783. + dect_mbc_put(mbc);
  13784. +}
  13785. +
  13786. +static void dect_mbc_timeout(unsigned long data)
  13787. +{
  13788. + struct dect_mbc *mbc = (struct dect_mbc *)data;
  13789. + struct dect_tb *tb;
  13790. + enum dect_release_reasons reason;
  13791. +
  13792. + mbc_debug(mbc, "timeout\n");
  13793. + reason = DECT_REASON_BEARER_SETUP_OR_HANDOVER_FAILED;
  13794. +
  13795. + list_for_each_entry(tb, &mbc->tbs, list)
  13796. + tb->ch->ops->tbc_dis_req(tb->ch, &tb->id, reason);
  13797. +
  13798. + if (mbc->state != DECT_MBC_NONE)
  13799. + dect_mac_dis_ind(mbc->cl, mbc->id.mcei, reason);
  13800. +
  13801. + dect_mbc_release(mbc);
  13802. +}
  13803. +
  13804. +static struct dect_mbc *dect_mbc_init(struct dect_cluster *cl,
  13805. + const struct dect_mbc_id *id)
  13806. +{
  13807. + struct dect_mbc *mbc;
  13808. +
  13809. + mbc = kzalloc(sizeof(*mbc), GFP_ATOMIC);
  13810. + if (mbc == NULL)
  13811. + return NULL;
  13812. + mbc->refcnt = 1;
  13813. + mbc->cl = cl;
  13814. + mbc->id = *id;
  13815. + mbc->state = DECT_MBC_NONE;
  13816. + mbc->ho_stamp = jiffies - DECT_MBC_HANDOVER_TIMER;
  13817. +
  13818. + INIT_LIST_HEAD(&mbc->tbs);
  13819. + dect_timer_setup(&mbc->normal_rx_timer, dect_mbc_normal_rx_timer, mbc);
  13820. + dect_timer_setup(&mbc->normal_tx_timer, dect_mbc_normal_tx_timer, mbc);
  13821. +
  13822. + mbc->cs_tx_seq = 1;
  13823. + mbc->cs_rx_seq = 1;
  13824. +
  13825. + setup_timer(&mbc->timer, dect_mbc_timeout, (unsigned long)mbc);
  13826. + list_add_tail(&mbc->list, &cl->mbcs);
  13827. + return mbc;
  13828. +}
  13829. +
  13830. +static int dect_mbc_tb_setup(struct dect_mbc *mbc, struct dect_tb *tb)
  13831. +{
  13832. + const struct dect_cell_handle *ch = tb->ch;
  13833. + int err;
  13834. +
  13835. + err = ch->ops->tbc_establish_req(ch, &tb->id, &mbc->mcp,
  13836. + tb->handover);
  13837. + if (err < 0)
  13838. + return err;
  13839. +
  13840. + mbc->setup_cnt++;
  13841. + return 0;
  13842. +}
  13843. +
  13844. +/**
  13845. + * dect_mac_con_req - request a new MAC connection
  13846. + *
  13847. + * @cl: DECT cluster
  13848. + * @id: MBC identifier
  13849. + */
  13850. +int dect_mac_con_req(struct dect_cluster *cl, const struct dect_mbc_id *id,
  13851. + const struct dect_mac_conn_params *mcp)
  13852. +{
  13853. + struct dect_cell_handle *ch;
  13854. + struct dect_mbc *mbc;
  13855. + struct dect_tb *tb;
  13856. + int err;
  13857. +
  13858. + err = -EHOSTUNREACH;
  13859. + ch = dect_cluster_get_cell_by_rpn(cl, 0);
  13860. + if (ch == NULL)
  13861. + goto err1;
  13862. +
  13863. + err = -ENOMEM;
  13864. + mbc = dect_mbc_init(cl, id);
  13865. + if (mbc == NULL)
  13866. + goto err1;
  13867. + mbc->state = DECT_MBC_INITIATED;
  13868. + mbc->mcp = *mcp;
  13869. + if (mcp->service != DECT_SERVICE_IN_MIN_DELAY ||
  13870. + mcp->slot != DECT_FULL_SLOT)
  13871. + mbc->mcp.type = DECT_MAC_CONN_ADVANCED;
  13872. + mbc_debug(mbc, "MAC_CON-req\n");
  13873. +
  13874. + tb = dect_mbc_tb_init(mbc, ch, 0xf);
  13875. + if (tb == NULL)
  13876. + goto err2;
  13877. +
  13878. + err = dect_mbc_tb_setup(mbc, tb);
  13879. + if (err < 0)
  13880. + goto err3;
  13881. +
  13882. + list_add_tail(&tb->list, &mbc->tbs);
  13883. + mod_timer(&mbc->timer, jiffies + DECT_MBC_SETUP_TIMEOUT);
  13884. + return 0;
  13885. +
  13886. +err3:
  13887. + dect_mbc_tb_release(tb);
  13888. +err2:
  13889. + dect_mbc_release(mbc);
  13890. +err1:
  13891. + return err;
  13892. +}
  13893. +
  13894. +void dect_mac_dis_req(struct dect_cluster *cl, u32 mcei)
  13895. +{
  13896. + const struct dect_cell_handle *ch;
  13897. + struct dect_mbc *mbc;
  13898. + struct dect_tb *tb;
  13899. +
  13900. + mbc = dect_mbc_get_by_mcei(cl, mcei);
  13901. + if (mbc == NULL)
  13902. + return;
  13903. + mbc_debug(mbc, "MAC_DIS-req\n");
  13904. +
  13905. + list_for_each_entry(tb, &mbc->tbs, list) {
  13906. + ch = tb->ch;
  13907. + ch->ops->tbc_dis_req(ch, &tb->id, DECT_REASON_CONNECTION_RELEASE);
  13908. + }
  13909. +
  13910. + dect_mbc_release(mbc);
  13911. +}
  13912. +
  13913. +/* TBC establishment indication from CSF */
  13914. +static int dect_tbc_establish_ind(const struct dect_cluster_handle *clh,
  13915. + const struct dect_cell_handle *ch,
  13916. + const struct dect_tbc_id *id,
  13917. + const struct dect_mac_conn_params *mcp,
  13918. + bool handover)
  13919. +{
  13920. + struct dect_cluster *cl = dect_cluster(clh);
  13921. + struct dect_mbc_id mid;
  13922. + struct dect_mbc *mbc;
  13923. + struct dect_tb *tb;
  13924. + unsigned int cnt;
  13925. + int err;
  13926. +
  13927. + mbc = dect_mbc_get_by_tbc_id(cl, id);
  13928. + if (mbc == NULL) {
  13929. + if (handover)
  13930. + return -ENOENT;
  13931. +
  13932. + mid.mcei = dect_mbc_alloc_mcei(cl);
  13933. + mid.ari = id->ari;
  13934. + mid.pmid = id->pmid;
  13935. + mid.ecn = id->ecn;
  13936. +
  13937. + err = -ENOMEM;
  13938. + mbc = dect_mbc_init(cl, &mid);
  13939. + if (mbc == NULL)
  13940. + goto err1;
  13941. + mbc->mcp = *mcp;
  13942. + } else {
  13943. + if (!handover)
  13944. + return -EEXIST;
  13945. +
  13946. + cnt = 0;
  13947. + list_for_each_entry(tb, &mbc->tbs, list) {
  13948. + if (tb->id.lbn == id->lbn)
  13949. + cnt++;
  13950. + }
  13951. + if (cnt > 1)
  13952. + return -EEXIST;
  13953. +
  13954. + if (mbc->cipher_state == DECT_CIPHER_ENABLED) {
  13955. + err = ch->ops->tbc_enc_req(ch, id, mbc->ck);
  13956. + if (err < 0)
  13957. + return err;
  13958. + }
  13959. + }
  13960. +
  13961. + mbc_debug(mbc, "TBC_ESTABLISH-ind: TBEI: %u LBN: %u H/O: %u\n",
  13962. + id->tbei, id->lbn, handover);
  13963. +
  13964. + err = -ENOMEM;
  13965. + tb = dect_mbc_tb_init(mbc, ch, id->lbn);
  13966. + if (tb == NULL)
  13967. + goto err2;
  13968. + tb->handover = handover;
  13969. +
  13970. + err = ch->ops->tbc_establish_res(ch, id);
  13971. + if (err < 0)
  13972. + goto err3;
  13973. +
  13974. + list_add_tail(&tb->list, &mbc->tbs);
  13975. + if (!handover)
  13976. + mod_timer(&mbc->timer, jiffies + DECT_MBC_SETUP_TIMEOUT);
  13977. + return 0;
  13978. +
  13979. +err3:
  13980. + dect_mbc_tb_release(tb);
  13981. +err2:
  13982. + dect_mbc_release(mbc);
  13983. +err1:
  13984. + return err;
  13985. +}
  13986. +
  13987. +static int dect_tbc_establish_cfm(const struct dect_cluster_handle *clh,
  13988. + const struct dect_tbc_id *id, bool success,
  13989. + u8 rx_slot)
  13990. +{
  13991. + struct dect_cluster *cl = dect_cluster(clh);
  13992. + const struct dect_cell_handle *ch;
  13993. + struct dect_mbc *mbc;
  13994. + struct dect_tb *tb, *i;
  13995. +
  13996. + mbc = dect_mbc_get_by_tbc_id(cl, id);
  13997. + if (mbc == NULL)
  13998. + return -ENOENT;
  13999. +
  14000. + mbc_debug(mbc, "TBC_ESTABLISH-cfm: TBEI: %u LBN: %u success: %d\n",
  14001. + id->tbei, id->lbn, success);
  14002. +
  14003. + tb = NULL;
  14004. + list_for_each_entry(i, &mbc->tbs, list) {
  14005. + if (i->id.lbn == id->lbn &&
  14006. + i->id.tbei == 0) {
  14007. + tb = i;
  14008. + break;
  14009. + }
  14010. + }
  14011. + if (tb == NULL)
  14012. + return -ENOENT;
  14013. +
  14014. + if (success) {
  14015. + tb->id.tbei = id->tbei;
  14016. + tb->rx_slot = rx_slot;
  14017. + tb->tx_slot = dect_tdd_slot(rx_slot);
  14018. +
  14019. + switch (mbc->state) {
  14020. + case DECT_MBC_NONE:
  14021. + if (!dect_mbc_complete_setup(cl, mbc))
  14022. + return 0;
  14023. + dect_mbc_tb_complete_setup(cl, tb);
  14024. +
  14025. + return dect_mac_con_ind(cl, &mbc->id, &mbc->mcp);
  14026. + case DECT_MBC_INITIATED:
  14027. + if (!dect_mbc_complete_setup(cl, mbc))
  14028. + return 0;
  14029. + dect_mbc_tb_complete_setup(cl, tb);
  14030. +
  14031. + return dect_mac_con_cfm(cl, mbc->id.mcei, &mbc->mcp);
  14032. + case DECT_MBC_ESTABLISHED:
  14033. + ch = tb->ch;
  14034. + if (mbc->cipher_state == DECT_CIPHER_ENABLED &&
  14035. + ch->ops->tbc_enc_req(ch, id, mbc->ck) < 0) {
  14036. + ch->ops->tbc_dis_req(ch, id, DECT_REASON_UNKNOWN);
  14037. + return -1;
  14038. + }
  14039. + dect_mbc_tb_complete_setup(cl, tb);
  14040. + return 0;
  14041. + default:
  14042. + return WARN_ON(-1);
  14043. + }
  14044. + } else {
  14045. + switch (mbc->state) {
  14046. + case DECT_MBC_NONE:
  14047. + dect_mbc_release(mbc);
  14048. + return 0;
  14049. + case DECT_MBC_INITIATED:
  14050. + if (mbc->setup_cnt > DECT_MBC_SETUP_MAX_ATTEMPTS ||
  14051. + dect_mbc_tb_setup(mbc, tb) < 0) {
  14052. + dect_mac_dis_ind(cl, mbc->id.mcei,
  14053. + DECT_REASON_BEARER_SETUP_OR_HANDOVER_FAILED);
  14054. + dect_mbc_release(mbc);
  14055. + }
  14056. + return 0;
  14057. + case DECT_MBC_ESTABLISHED:
  14058. + list_del(&tb->list);
  14059. + dect_mbc_tb_release(tb);
  14060. + return 0;
  14061. + default:
  14062. + return WARN_ON(-1);
  14063. + }
  14064. + }
  14065. +}
  14066. +
  14067. +static int dect_tbc_event_ind(const struct dect_cluster_handle *clh,
  14068. + const struct dect_tbc_id *id,
  14069. + enum dect_tbc_event event)
  14070. +{
  14071. + struct dect_cluster *cl = dect_cluster(clh);
  14072. + struct dect_mbc *mbc;
  14073. + struct dect_tb *tb;
  14074. +
  14075. + mbc = dect_mbc_get_by_tbc_id(cl, id);
  14076. + if (mbc == NULL)
  14077. + return -ENOENT;
  14078. + mbc_debug(mbc, "TBC_EVENT-ind: TBEI: %u LBN: %u event: %u\n",
  14079. + id->tbei, id->lbn, event);
  14080. +
  14081. + tb = dect_mbc_tb_get_by_tbei(mbc, id);
  14082. + if (tb == NULL)
  14083. + return -ENOENT;
  14084. +
  14085. + switch (event) {
  14086. + case DECT_TBC_ACK_RECEIVED:
  14087. + mbc->cs_rx_ok = true;
  14088. + return 0;
  14089. + case DECT_TBC_CIPHER_ENABLED:
  14090. + mbc->cipher_state = DECT_TBC_CIPHER_ENABLED;
  14091. + dect_mac_enc_eks_ind(cl, mbc->id.mcei, DECT_CIPHER_ENABLED);
  14092. + return 0;
  14093. + case DECT_TBC_CIPHER_DISABLED:
  14094. + mbc->cipher_state = DECT_TBC_CIPHER_DISABLED;
  14095. + dect_mac_enc_eks_ind(cl, mbc->id.mcei, DECT_CIPHER_DISABLED);
  14096. + return 0;
  14097. + default:
  14098. + return WARN_ON(-1);
  14099. + }
  14100. +}
  14101. +
  14102. +static int dect_tbc_handover_req(const struct dect_cluster_handle *clh,
  14103. + const struct dect_tbc_id *id)
  14104. +{
  14105. + struct dect_cluster *cl = dect_cluster(clh);
  14106. + struct dect_cell_handle *ch;
  14107. + struct dect_mbc *mbc;
  14108. + struct dect_tb *tb;
  14109. + unsigned int cnt;
  14110. + int err;
  14111. +
  14112. + mbc = dect_mbc_get_by_tbc_id(cl, id);
  14113. + if (mbc == NULL)
  14114. + return -ENOENT;
  14115. + mbc_debug(mbc, "TBC_HANDOVER-req: TBEI: %u LBN: %u\n",
  14116. + id->tbei, id->lbn);
  14117. +
  14118. + /* Handover already in progress or two bearers active?? */
  14119. + cnt = 0;
  14120. + list_for_each_entry(tb, &mbc->tbs, list) {
  14121. + if (tb->id.lbn != id->lbn)
  14122. + continue;
  14123. + if (tb->id.tbei == 0)
  14124. + return 0;
  14125. + cnt++;
  14126. + }
  14127. + if (cnt > 1)
  14128. + return 0;
  14129. +
  14130. + /* Handover rate-limiting */
  14131. + if (mbc->ho_tokens == 0) {
  14132. + if (time_after_eq(jiffies, mbc->ho_stamp + DECT_MBC_HANDOVER_TIMER)) {
  14133. + mbc->ho_tokens = DECT_MBC_HANDOVER_LIMIT;
  14134. + mbc->ho_stamp = jiffies;
  14135. + }
  14136. + mbc_debug(mbc, "handover: tokens: %u\n", mbc->ho_tokens);
  14137. + if (mbc->ho_tokens == 0)
  14138. + return 0;
  14139. + }
  14140. +
  14141. + ch = dect_cluster_get_cell_by_rpn(cl, 0);
  14142. + if (ch == NULL)
  14143. + return -EHOSTUNREACH;
  14144. +
  14145. + tb = dect_mbc_tb_init(mbc, ch, id->lbn);
  14146. + if (tb == NULL)
  14147. + return -ENOMEM;
  14148. + tb->handover = true;
  14149. +
  14150. + err = dect_mbc_tb_setup(mbc, tb);
  14151. + if (err < 0)
  14152. + goto err1;
  14153. +
  14154. + list_add_tail(&tb->list, &mbc->tbs);
  14155. + mbc->ho_tokens--;
  14156. + return 0;
  14157. +
  14158. +err1:
  14159. + dect_mbc_tb_release(tb);
  14160. + return err;
  14161. +}
  14162. +
  14163. +/* TBC release indication from CSF */
  14164. +static void dect_tbc_dis_ind(const struct dect_cluster_handle *clh,
  14165. + const struct dect_tbc_id *id,
  14166. + enum dect_release_reasons reason)
  14167. +{
  14168. + struct dect_cluster *cl = dect_cluster(clh);
  14169. + struct dect_mbc *mbc;
  14170. + struct dect_tb *tb;
  14171. +
  14172. + mbc = dect_mbc_get_by_tbc_id(cl, id);
  14173. + if (mbc == NULL)
  14174. + return;
  14175. + mbc_debug(mbc, "TBC_DIS-ind: TBEI: %u LBN: %u reason: %u\n",
  14176. + id->tbei, id->lbn, reason);
  14177. +
  14178. + tb = dect_mbc_tb_get_by_tbei(mbc, id);
  14179. + if (tb == NULL)
  14180. + return;
  14181. +
  14182. + list_del(&tb->list);
  14183. + dect_mbc_tb_release(tb);
  14184. + if (!list_empty(&mbc->tbs))
  14185. + return;
  14186. +
  14187. + dect_mac_dis_ind(cl, mbc->id.mcei, reason);
  14188. + dect_mbc_release(mbc);
  14189. +}
  14190. +
  14191. +/* Set Encryption key request from DLC */
  14192. +int dect_mac_enc_key_req(const struct dect_cluster *cl, u32 mcei, u64 ck)
  14193. +{
  14194. + struct dect_mbc *mbc;
  14195. + struct dect_tb *tb;
  14196. + int err;
  14197. +
  14198. + mbc = dect_mbc_get_by_mcei(cl, mcei);
  14199. + if (mbc == NULL)
  14200. + return -ENOENT;
  14201. + mbc_debug(mbc, "MAC_ENC_KEY-req: key: %016llx\n", (unsigned long long)ck);
  14202. +
  14203. + mbc->ck = ck;
  14204. + list_for_each_entry(tb, &mbc->tbs, list) {
  14205. + err = tb->ch->ops->tbc_enc_key_req(tb->ch, &tb->id, ck);
  14206. + if (err < 0)
  14207. + return err;
  14208. + }
  14209. +
  14210. + return 0;
  14211. +}
  14212. +
  14213. +/* Change encryption status requst from DLC */
  14214. +int dect_mac_enc_eks_req(const struct dect_cluster *cl, u32 mcei,
  14215. + enum dect_cipher_states status)
  14216. +{
  14217. + struct dect_mbc *mbc;
  14218. + struct dect_tb *tb;
  14219. + int err;
  14220. +
  14221. + mbc = dect_mbc_get_by_mcei(cl, mcei);
  14222. + if (mbc == NULL)
  14223. + return -ENOENT;
  14224. + mbc_debug(mbc, "MAC_ENC_EKS-req: status: %d\n", status);
  14225. +
  14226. + if (mbc->cipher_state == status)
  14227. + return 0;
  14228. +
  14229. + list_for_each_entry(tb, &mbc->tbs, list) {
  14230. + err = tb->ch->ops->tbc_enc_eks_req(tb->ch, &tb->id, status);
  14231. + if (err < 0)
  14232. + return err;
  14233. + }
  14234. + return 0;
  14235. +}
  14236. +
  14237. +static void dect_tbc_data_ind(const struct dect_cluster_handle *clh,
  14238. + const struct dect_tbc_id *id,
  14239. + enum dect_data_channels chan,
  14240. + struct sk_buff *skb)
  14241. +{
  14242. + const struct dect_cluster *cl = dect_cluster(clh);
  14243. + struct dect_mbc *mbc;
  14244. + struct dect_tb *tb;
  14245. +
  14246. + mbc = dect_mbc_get_by_tbc_id(cl, id);
  14247. + if (mbc == NULL)
  14248. + goto err;
  14249. + mbc_debug(mbc, "TBC_DATA-ind: TBEI: %u LBN: %u chan: %u len: %u\n",
  14250. + id->tbei, id->lbn, chan, skb->len);
  14251. +
  14252. + switch (chan) {
  14253. + case DECT_MC_C_S:
  14254. + /* Drop duplicate segments */
  14255. + if (DECT_CS_CB(skb)->seq != mbc->cs_rx_seq)
  14256. + goto err;
  14257. + if (mbc->cs_rx_skb != NULL)
  14258. + goto err;
  14259. + mbc->cs_rx_seq = !mbc->cs_rx_seq;
  14260. + mbc->cs_rx_skb = skb;
  14261. + return;
  14262. + case DECT_MC_I_N:
  14263. + tb = dect_mbc_tb_get_by_tbei(mbc, id);
  14264. + if (tb == NULL)
  14265. + goto err;
  14266. + tb->b_rx_skb = skb;
  14267. + return;
  14268. + default:
  14269. + break;
  14270. + }
  14271. +err:
  14272. + kfree_skb(skb);
  14273. +}
  14274. +
  14275. +static void dect_cluster_unbind_cell(struct dect_cluster_handle *clh,
  14276. + struct dect_cell_handle *ch)
  14277. +{
  14278. + list_del(&ch->list);
  14279. +}
  14280. +
  14281. +static int dect_cluster_enable_cell(struct dect_cluster *cl,
  14282. + struct dect_cell_handle *ch)
  14283. +{
  14284. + int err;
  14285. +
  14286. + err = ch->ops->preload(ch, &cl->pari, ch->rpn, &cl->si);
  14287. + if (err < 0)
  14288. + return err;
  14289. +
  14290. + err = ch->ops->enable(ch);
  14291. + if (err < 0)
  14292. + return err;
  14293. + return 0;
  14294. +}
  14295. +
  14296. +static int dect_cluster_bind_cell(struct dect_cluster_handle *clh,
  14297. + struct dect_cell_handle *ch)
  14298. +{
  14299. + struct dect_cluster *cl = dect_cluster(clh);
  14300. + u8 rpn, max;
  14301. + int err;
  14302. +
  14303. + /* Allocate RPN for the cell */
  14304. + max = 8;
  14305. + for (rpn = 0; rpn < max; rpn++) {
  14306. + if (!dect_cluster_get_cell_by_rpn(cl, rpn))
  14307. + break;
  14308. + }
  14309. + if (rpn == max)
  14310. + return -EMFILE;
  14311. +
  14312. + ch->clh = clh;
  14313. + ch->rpn = rpn;
  14314. +
  14315. + err = ch->ops->set_mode(ch, cl->mode);
  14316. + if (err < 0)
  14317. + return err;
  14318. +
  14319. + err = dect_cluster_enable_cell(cl, ch);
  14320. + if (err < 0)
  14321. + return err;
  14322. +
  14323. + list_add_tail(&ch->list, &cl->cells);
  14324. + return 0;
  14325. +}
  14326. +
  14327. +static const struct dect_ccf_ops dect_ccf_ops = {
  14328. + .bind = dect_cluster_bind_cell,
  14329. + .unbind = dect_cluster_unbind_cell,
  14330. + .time_ind = dect_ccf_time_ind,
  14331. + .scan_report = dect_scan_report,
  14332. + .mac_info_ind = dect_mac_info_ind,
  14333. + .tbc_establish_ind = dect_tbc_establish_ind,
  14334. + .tbc_establish_cfm = dect_tbc_establish_cfm,
  14335. + .tbc_event_ind = dect_tbc_event_ind,
  14336. + .tbc_handover_req = dect_tbc_handover_req,
  14337. + .tbc_dis_ind = dect_tbc_dis_ind,
  14338. + .tbc_data_ind = dect_tbc_data_ind,
  14339. + .bmc_page_ind = dect_bmc_page_ind,
  14340. +};
  14341. +
  14342. +static int dect_cluster_preload(struct dect_cluster *cl,
  14343. + const struct dect_ari *pari,
  14344. + const struct dect_si *si)
  14345. +{
  14346. + const struct dect_cell_handle *ch;
  14347. + int err = 0;
  14348. +
  14349. + list_for_each_entry(ch, &cl->cells, list) {
  14350. + err = ch->ops->preload(ch, pari, ch->rpn, si);
  14351. + if (err < 0)
  14352. + return err;
  14353. + }
  14354. +
  14355. + cl->pari = *pari;
  14356. + cl->si = *si;
  14357. + return 0;
  14358. +}
  14359. +
  14360. +static int dect_cluster_scan(struct dect_cluster *cl,
  14361. + const struct dect_llme_req *lreq,
  14362. + const struct dect_ari *pari,
  14363. + const struct dect_ari *pari_mask)
  14364. +{
  14365. + struct dect_cell_handle *ch;
  14366. +
  14367. + ch = dect_cluster_get_cell_by_rpn(cl, 0);
  14368. + if (ch == NULL)
  14369. + return -ENOENT;
  14370. + return ch->ops->scan(ch, lreq, pari, pari_mask);
  14371. +}
  14372. +
  14373. +static void dect_fp_init_si(struct dect_cluster *cl)
  14374. +{
  14375. + struct dect_si *si = &cl->si;
  14376. +
  14377. + /* Make phone not go into "call technician" mode :) */
  14378. + si->fpc.fpc = DECT_FPC_FULL_SLOT |
  14379. + DECT_FPC_CO_SETUP_ON_DUMMY |
  14380. + DECT_FPC_CL_UPLINK |
  14381. + DECT_FPC_CL_DOWNLINK |
  14382. + DECT_FPC_BASIC_A_FIELD_SETUP |
  14383. + DECT_FPC_ADV_A_FIELD_SETUP |
  14384. + DECT_FPC_CF_MESSAGES |
  14385. + DECT_FPC_IN_MIN_DELAY |
  14386. + DECT_FPC_IN_NORM_DELAY |
  14387. + DECT_FPC_IP_ERROR_DETECTION |
  14388. + DECT_FPC_IP_ERROR_CORRECTION |
  14389. + DECT_FPC_EXTENDED_FP_INFO;
  14390. + si->efpc.fpc = DECT_EFPC_EXTENDED_FP_INFO2;
  14391. + si->efpc2.fpc = DECT_EFPC2_LONG_SLOT_J640;
  14392. + si->fpc.hlc = DECT_HLC_ADPCM_G721_VOICE |
  14393. + DECT_HLC_GAP_PAP_BASIC_SPEECH |
  14394. + DECT_HLC_CISS_SERVICE |
  14395. + DECT_HLC_CLMS_SERVICE |
  14396. + DECT_HLC_COMS_SERVICE |
  14397. + DECT_HLC_LOCATION_REGISTRATION |
  14398. + DECT_HLC_ACCESS_RIGHTS_REQUESTS |
  14399. + DECT_HLC_STANDARD_AUTHENTICATION |
  14400. + DECT_HLC_STANDARD_CIPHERING;
  14401. +}
  14402. +
  14403. +static int dect_cluster_init(struct dect_cluster *cl)
  14404. +{
  14405. + spin_lock_init(&cl->lock);
  14406. + INIT_LIST_HEAD(&cl->bmc.bcs);
  14407. + INIT_LIST_HEAD(&cl->mbcs);
  14408. + INIT_LIST_HEAD(&cl->cells);
  14409. + INIT_LIST_HEAD(&cl->mac_connections);
  14410. + dect_timer_base_init(cl->timer_base, DECT_TIMER_TX);
  14411. + dect_timer_base_init(cl->timer_base, DECT_TIMER_RX);
  14412. +
  14413. + if (cl->mode == DECT_MODE_FP)
  14414. + dect_fp_init_si(cl);
  14415. +
  14416. + cl->handle.ops = &dect_ccf_ops;
  14417. + cl->handle.index = cl->index;
  14418. +
  14419. + return dect_ccp_cluster_init(cl);
  14420. +}
  14421. +
  14422. +static void dect_cluster_shutdown(struct dect_cluster *cl)
  14423. +{
  14424. + struct dect_cell_handle *ch, *ch_next;
  14425. + struct dect_mbc *mbc, *mbc_next;
  14426. +
  14427. + list_for_each_entry_safe(mbc, mbc_next, &cl->mbcs, list) {
  14428. + dect_mac_dis_ind(cl, mbc->id.mcei, DECT_REASON_UNKNOWN);
  14429. + dect_mbc_release(mbc);
  14430. + }
  14431. +
  14432. + list_for_each_entry_safe(ch, ch_next, &cl->cells, list)
  14433. + dect_cluster_unbind_cell(&cl->handle, ch);
  14434. +
  14435. + dect_ccp_cluster_shutdown(cl);
  14436. +}
  14437. +
  14438. +/*
  14439. + * LLME netlink interface
  14440. + */
  14441. +
  14442. +static struct sk_buff *dect_llme_fill(const struct dect_cluster *cl,
  14443. + const struct dect_llme_req *lreq,
  14444. + u8 op, u8 type,
  14445. + int (*fill)(const struct dect_cluster *,
  14446. + struct sk_buff *, const void *),
  14447. + const void *data);
  14448. +
  14449. +static void dect_llme_req_init(struct dect_llme_req *lreq,
  14450. + const struct nlmsghdr *nlh,
  14451. + const struct sk_buff *skb)
  14452. +{
  14453. + memcpy(&lreq->nlh, nlh, sizeof(lreq->nlh));
  14454. + lreq->nlportid = NETLINK_CB(skb).portid;
  14455. +}
  14456. +
  14457. +static int dect_fill_ari(struct sk_buff *skb, const struct dect_ari *ari, int attr)
  14458. +{
  14459. + struct nlattr *nla;
  14460. +
  14461. + nla = nla_nest_start(skb, attr);
  14462. + if (nla == NULL)
  14463. + goto nla_put_failure;
  14464. +
  14465. + if (nla_put_u8(skb, DECTA_ARI_CLASS, ari->arc) ||
  14466. + nla_put_u32(skb, DECTA_ARI_FPN, ari->fpn))
  14467. + goto nla_put_failure;
  14468. +
  14469. + switch (ari->arc) {
  14470. + case DECT_ARC_A:
  14471. + if (nla_put_u16(skb, DECTA_ARI_EMC, ari->emc))
  14472. + goto nla_put_failure;
  14473. + break;
  14474. + case DECT_ARC_B:
  14475. + if (nla_put_u16(skb, DECTA_ARI_EIC, ari->eic) ||
  14476. + nla_put_u32(skb, DECTA_ARI_FPS, ari->fps))
  14477. + goto nla_put_failure;
  14478. + break;
  14479. + case DECT_ARC_C:
  14480. + if (nla_put_u16(skb, DECTA_ARI_POC, ari->poc) ||
  14481. + nla_put_u32(skb, DECTA_ARI_FPS, ari->fps))
  14482. + goto nla_put_failure;
  14483. + break;
  14484. + case DECT_ARC_D:
  14485. + if (nla_put_u32(skb, DECTA_ARI_GOP, ari->gop))
  14486. + goto nla_put_failure;
  14487. + break;
  14488. + case DECT_ARC_E:
  14489. + if (nla_put_u16(skb, DECTA_ARI_FIL, ari->fil))
  14490. + goto nla_put_failure;
  14491. + break;
  14492. + }
  14493. + nla_nest_end(skb, nla);
  14494. + return 0;
  14495. +
  14496. +nla_put_failure:
  14497. + return -1;
  14498. +}
  14499. +
  14500. +static const struct nla_policy dect_ari_policy[DECTA_ARI_MAX + 1] = {
  14501. + [DECTA_ARI_CLASS] = { .type = NLA_U8 },
  14502. + [DECTA_ARI_FPN] = { .type = NLA_U32 },
  14503. + [DECTA_ARI_FPS] = { .type = NLA_U32 },
  14504. + [DECTA_ARI_EMC] = { .type = NLA_U16 },
  14505. + [DECTA_ARI_EIC] = { .type = NLA_U16 },
  14506. + [DECTA_ARI_POC] = { .type = NLA_U16 },
  14507. + [DECTA_ARI_GOP] = { .type = NLA_U32 },
  14508. + [DECTA_ARI_FIL] = { .type = NLA_U32 },
  14509. +};
  14510. +
  14511. +static const u32 dect_ari_valid_attrs[] = {
  14512. + [DECT_ARC_A] = (1 << DECTA_ARI_EMC),
  14513. + [DECT_ARC_B] = (1 << DECTA_ARI_EIC) | (1 << DECTA_ARI_FPS),
  14514. + [DECT_ARC_C] = (1 << DECTA_ARI_POC) | (1 << DECTA_ARI_FPS),
  14515. + [DECT_ARC_D] = (1 << DECTA_ARI_GOP),
  14516. + [DECT_ARC_E] = (1 << DECTA_ARI_FIL),
  14517. +};
  14518. +
  14519. +static int dect_nla_parse_ari(struct dect_ari *ari, const struct nlattr *nla)
  14520. +{
  14521. + struct nlattr *tb[DECTA_ARI_MAX + 1];
  14522. + unsigned int attr;
  14523. + int err;
  14524. +
  14525. + err = nla_parse_nested(tb, DECTA_ARI_MAX, nla, dect_ari_policy);
  14526. + if (err < 0)
  14527. + return err;
  14528. +
  14529. + if (tb[DECTA_ARI_CLASS] == NULL)
  14530. + return -EINVAL;
  14531. +
  14532. + memset(ari, 0, sizeof(ari));
  14533. + ari->arc = nla_get_u8(tb[DECTA_ARI_CLASS]);
  14534. + if (ari->arc > DECT_ARC_E)
  14535. + return -EINVAL;
  14536. +
  14537. + for (attr = DECTA_ARI_UNSPEC + 1; attr <= DECTA_ARI_MAX; attr++) {
  14538. + if (tb[attr] == NULL)
  14539. + continue;
  14540. +
  14541. + switch (attr) {
  14542. + case DECTA_ARI_CLASS:
  14543. + case DECTA_ARI_FPN:
  14544. + /* always valid */
  14545. + break;
  14546. + default:
  14547. + if (!(dect_ari_valid_attrs[ari->arc] & (1 << attr)))
  14548. + return -EINVAL;
  14549. + break;
  14550. + }
  14551. + }
  14552. +
  14553. + if (tb[DECTA_ARI_FPN] != NULL)
  14554. + ari->fpn = nla_get_u32(tb[DECTA_ARI_FPN]);
  14555. + if (tb[DECTA_ARI_FPS] != NULL)
  14556. + ari->fps = nla_get_u32(tb[DECTA_ARI_FPS]);
  14557. +
  14558. + switch (ari->arc) {
  14559. + case DECT_ARC_A:
  14560. + if (tb[DECTA_ARI_EMC] != NULL)
  14561. + ari->emc = nla_get_u16(tb[DECTA_ARI_EMC]);
  14562. + break;
  14563. + case DECT_ARC_B:
  14564. + if (tb[DECTA_ARI_EIC] != NULL)
  14565. + ari->eic = nla_get_u16(tb[DECTA_ARI_EIC]);
  14566. + break;
  14567. + case DECT_ARC_C:
  14568. + if (tb[DECTA_ARI_POC] != NULL)
  14569. + ari->poc = nla_get_u16(tb[DECTA_ARI_POC]);
  14570. + break;
  14571. + case DECT_ARC_D:
  14572. + if (tb[DECTA_ARI_GOP] != NULL)
  14573. + ari->gop = nla_get_u32(tb[DECTA_ARI_GOP]);
  14574. + break;
  14575. + case DECT_ARC_E:
  14576. + if (tb[DECTA_ARI_FIL] != NULL)
  14577. + ari->fil = nla_get_u16(tb[DECTA_ARI_FIL]);
  14578. + break;
  14579. + }
  14580. + return 0;
  14581. +}
  14582. +
  14583. +static int dect_fill_sari(struct sk_buff *skb, const struct dect_sari *sari,
  14584. + int attr)
  14585. +{
  14586. + struct nlattr *nla;
  14587. +
  14588. + nla = nla_nest_start(skb, attr);
  14589. + if (nla == NULL)
  14590. + goto nla_put_failure;
  14591. + if (dect_fill_ari(skb, &sari->ari, DECTA_SARI_ARI) < 0)
  14592. + goto nla_put_failure;
  14593. + if (sari->black &&
  14594. + nla_put_flag(skb, DECTA_SARI_BLACK))
  14595. + goto nla_put_failure;
  14596. + if (sari->tari &&
  14597. + nla_put_flag(skb, DECTA_SARI_TARI))
  14598. + goto nla_put_failure;
  14599. + nla_nest_end(skb, nla);
  14600. + return 0;
  14601. +
  14602. +nla_put_failure:
  14603. + return -1;
  14604. +}
  14605. +
  14606. +static int dect_llme_fill_mac_info(const struct dect_cluster *cl,
  14607. + struct sk_buff *skb, const void *data)
  14608. +{
  14609. + const struct dect_si *si = data;
  14610. + struct nlattr *nla;
  14611. + unsigned int i;
  14612. +
  14613. + if (si->mask & (1 << DECT_TM_TYPE_SARI) && si->num_saris > 0) {
  14614. + nla = nla_nest_start(skb, DECTA_MAC_INFO_SARI_LIST);
  14615. + if (nla == NULL)
  14616. + goto nla_put_failure;
  14617. + for (i = 0; i < si->num_saris; i++) {
  14618. + if (dect_fill_sari(skb, &si->sari[i],
  14619. + DECTA_LIST_ELEM) < 0)
  14620. + goto nla_put_failure;
  14621. + }
  14622. + nla_nest_end(skb, nla);
  14623. + }
  14624. +
  14625. + if (nla_put_u8(skb, DECTA_MAC_INFO_RPN, cl->rpn))
  14626. + goto nla_put_failure;
  14627. +
  14628. + if (si->mask & (1 << DECT_TM_TYPE_FPC)) {
  14629. + if (nla_put_u32(skb, DECTA_MAC_INFO_FPC, si->fpc.fpc) ||
  14630. + nla_put_u16(skb, DECTA_MAC_INFO_HLC, si->fpc.hlc))
  14631. + goto nla_put_failure;
  14632. + }
  14633. +
  14634. + if (si->mask & (1 << DECT_TM_TYPE_EFPC)) {
  14635. + if (nla_put_u16(skb, DECTA_MAC_INFO_EFPC, si->efpc.fpc) ||
  14636. + nla_put_u32(skb, DECTA_MAC_INFO_EHLC, si->efpc.hlc))
  14637. + goto nla_put_failure;
  14638. + }
  14639. +
  14640. + if (si->mask & (1 << DECT_TM_TYPE_EFPC2)) {
  14641. + if (nla_put_u16(skb, DECTA_MAC_INFO_EFPC2, si->efpc2.fpc) ||
  14642. + nla_put_u32(skb, DECTA_MAC_INFO_EHLC2, si->efpc2.hlc))
  14643. + goto nla_put_failure;
  14644. + }
  14645. +
  14646. + return 0;
  14647. +
  14648. +nla_put_failure:
  14649. + return -EMSGSIZE;
  14650. +}
  14651. +
  14652. +static int dect_llme_fill_scan_result(const struct dect_cluster *cl,
  14653. + struct sk_buff *skb, const void *data)
  14654. +{
  14655. + const struct dect_scan_result *res = data;
  14656. + const struct dect_idi *idi = &res->idi;
  14657. + const struct dect_si *si = &res->si;
  14658. +
  14659. + if (nla_put_u8(skb, DECTA_MAC_INFO_RSSI,
  14660. + res->rssi >> DECT_RSSI_AVG_SCALE) ||
  14661. + dect_fill_ari(skb, &idi->pari, DECTA_MAC_INFO_PARI) < 0 ||
  14662. + nla_put_u8(skb, DECTA_MAC_INFO_RPN, idi->rpn))
  14663. + goto nla_put_failure;
  14664. +
  14665. + dect_llme_fill_mac_info(cl, skb, si);
  14666. + return 0;
  14667. +
  14668. +nla_put_failure:
  14669. + return -EMSGSIZE;
  14670. +}
  14671. +
  14672. +static void dect_llme_scan_result_notify(const struct dect_cluster *cl,
  14673. + const struct dect_scan_result *res)
  14674. +{
  14675. + struct sk_buff *skb;
  14676. + u32 portid = res->lreq.nlportid;
  14677. + int err = 0;
  14678. +
  14679. + skb = dect_llme_fill(cl, &res->lreq,
  14680. + DECT_LLME_INDICATE, DECT_LLME_MAC_INFO,
  14681. + dect_llme_fill_scan_result, res);
  14682. + if (IS_ERR(skb)) {
  14683. + err = PTR_ERR(skb);
  14684. + goto err;
  14685. + }
  14686. + nlmsg_notify(dect_nlsk, skb, portid, DECTNLGRP_LLME, 1, GFP_ATOMIC);
  14687. +err:
  14688. + if (err < 0)
  14689. + netlink_set_err(dect_nlsk, portid, DECTNLGRP_LLME, err);
  14690. +}
  14691. +
  14692. +static void dect_llme_mac_info_ind(const struct dect_cluster *cl,
  14693. + const struct dect_idi *idi,
  14694. + const struct dect_si *si)
  14695. +{
  14696. + struct sk_buff *skb;
  14697. + int err = 0;
  14698. +
  14699. + skb = dect_llme_fill(cl, NULL,
  14700. + DECT_LLME_INDICATE, DECT_LLME_MAC_INFO,
  14701. + dect_llme_fill_mac_info, si);
  14702. + if (IS_ERR(skb)) {
  14703. + err = PTR_ERR(skb);
  14704. + goto err;
  14705. + }
  14706. + nlmsg_notify(dect_nlsk, skb, 0, DECTNLGRP_LLME, 0, GFP_ATOMIC);
  14707. +err:
  14708. + if (err < 0)
  14709. + netlink_set_err(dect_nlsk, 0, DECTNLGRP_LLME, err);
  14710. +}
  14711. +
  14712. +static int dect_llme_mac_info_req(struct dect_cluster *cl,
  14713. + const struct sk_buff *skb_in,
  14714. + const struct nlmsghdr *nlh,
  14715. + const struct nlattr *tb[DECTA_MAC_INFO_MAX + 1])
  14716. +{
  14717. + struct dect_llme_req lreq;
  14718. + struct sk_buff *skb;
  14719. +
  14720. + dect_llme_req_init(&lreq, nlh, skb_in);
  14721. + skb = dect_llme_fill(cl, &lreq,
  14722. + DECT_LLME_INDICATE, DECT_LLME_MAC_INFO,
  14723. + dect_llme_fill_mac_info, &cl->si);
  14724. + if (IS_ERR(skb))
  14725. + return PTR_ERR(skb);
  14726. +
  14727. + return nlmsg_unicast(dect_nlsk, skb, lreq.nlportid);
  14728. +}
  14729. +
  14730. +static int dect_llme_mac_info_res(struct dect_cluster *cl,
  14731. + const struct sk_buff *skb_in,
  14732. + const struct nlmsghdr *nlh,
  14733. + const struct nlattr *tb[DECTA_MAC_INFO_MAX + 1])
  14734. +{
  14735. + struct dect_cell_handle *ch;
  14736. + struct dect_ari pari;
  14737. + int err;
  14738. +
  14739. + if (cl->mode != DECT_MODE_PP)
  14740. + return -EOPNOTSUPP;
  14741. +
  14742. + if (tb[DECTA_MAC_INFO_PARI] != NULL) {
  14743. + err = dect_nla_parse_ari(&pari, tb[DECTA_MAC_INFO_PARI]);
  14744. + if (err < 0)
  14745. + return err;
  14746. + } else
  14747. + return -EINVAL;
  14748. +
  14749. + ch = dect_cluster_get_cell_by_rpn(cl, 0);
  14750. + if (ch == NULL)
  14751. + return -EHOSTUNREACH;
  14752. +
  14753. + cl->pari = pari;
  14754. + memset(&cl->si, 0, sizeof(cl->si));
  14755. +
  14756. + return dect_cluster_enable_cell(cl, ch);
  14757. +}
  14758. +
  14759. +static const struct nla_policy dect_llme_mac_info_policy[DECTA_MAC_INFO_MAX + 1] = {
  14760. + [DECTA_MAC_INFO_PARI] = { .type = NLA_NESTED },
  14761. + [DECTA_MAC_INFO_RPN] = { .type = NLA_U8 },
  14762. + [DECTA_MAC_INFO_RSSI] = { .type = NLA_U8 },
  14763. + [DECTA_MAC_INFO_SARI_LIST] = { .type = NLA_NESTED },
  14764. + [DECTA_MAC_INFO_FPC] = { .type = NLA_U32 },
  14765. + [DECTA_MAC_INFO_HLC] = { .type = NLA_U16 },
  14766. + [DECTA_MAC_INFO_EFPC] = { .type = NLA_U16 },
  14767. + [DECTA_MAC_INFO_EHLC] = { .type = NLA_U32 },
  14768. + [DECTA_MAC_INFO_EFPC2] = { .type = NLA_U16 },
  14769. + [DECTA_MAC_INFO_EHLC2] = { .type = NLA_U32 },
  14770. +};
  14771. +
  14772. +static int dect_llme_scan_request(struct dect_cluster *cl,
  14773. + const struct sk_buff *skb,
  14774. + const struct nlmsghdr *nlh,
  14775. + const struct nlattr *tb[DECTA_MAC_INFO_MAX + 1])
  14776. +{
  14777. + struct dect_llme_req lreq;
  14778. + struct dect_ari pari, pari_mask;
  14779. + int err;
  14780. +
  14781. + if (tb[DECTA_MAC_INFO_PARI] != NULL) {
  14782. + err = dect_nla_parse_ari(&pari, tb[DECTA_MAC_INFO_PARI]);
  14783. + if (err < 0)
  14784. + return err;
  14785. + } else
  14786. + memset(&pari, 0, sizeof(pari));
  14787. + memset(&pari_mask, 0, sizeof(pari_mask));
  14788. +
  14789. + dect_llme_req_init(&lreq, nlh, skb);
  14790. + return dect_cluster_scan(cl, &lreq, &pari, &pari_mask);
  14791. +}
  14792. +
  14793. +static int dect_llme_mac_rfp_preload(struct dect_cluster *cl,
  14794. + const struct sk_buff *skb,
  14795. + const struct nlmsghdr *nlh,
  14796. + const struct nlattr *tb[DECTA_MAC_INFO_MAX + 1])
  14797. +{
  14798. + struct dect_ari pari;
  14799. + struct dect_si si;
  14800. + int err = 0;
  14801. + u32 num;
  14802. +
  14803. + if (cl->mode != DECT_MODE_FP)
  14804. + return -EINVAL;
  14805. +
  14806. + if (tb[DECTA_MAC_INFO_PARI] != NULL) {
  14807. + err = dect_nla_parse_ari(&pari, tb[DECTA_MAC_INFO_PARI]);
  14808. + if (err < 0)
  14809. + return err;
  14810. + } else
  14811. + pari = cl->pari;
  14812. +
  14813. + si = cl->si;
  14814. + if (tb[DECTA_MAC_INFO_HLC])
  14815. + si.fpc.hlc = nla_get_u16(tb[DECTA_MAC_INFO_HLC]);
  14816. + if (tb[DECTA_MAC_INFO_EHLC])
  14817. + si.efpc.hlc = nla_get_u32(tb[DECTA_MAC_INFO_EHLC]);
  14818. + if (tb[DECTA_MAC_INFO_EHLC2])
  14819. + si.efpc2.hlc = nla_get_u32(tb[DECTA_MAC_INFO_EHLC2]);
  14820. +
  14821. + if (si.efpc2.fpc || si.efpc2.hlc)
  14822. + si.efpc.fpc |= DECT_EFPC_EXTENDED_FP_INFO2;
  14823. + else
  14824. + si.efpc.fpc &= ~DECT_EFPC_EXTENDED_FP_INFO2;
  14825. +
  14826. + if (si.efpc.fpc || si.efpc.hlc)
  14827. + si.fpc.fpc |= DECT_FPC_EXTENDED_FP_INFO;
  14828. + else
  14829. + si.fpc.fpc &= ~DECT_FPC_EXTENDED_FP_INFO;
  14830. +
  14831. + if (tb[DECTA_MAC_INFO_MFN]) {
  14832. + num = nla_get_u32(tb[DECTA_MAC_INFO_MFN]);
  14833. + if (num >= (1 << 24))
  14834. + return -EINVAL;
  14835. + si.mfn.num = num;
  14836. + }
  14837. +
  14838. + return dect_cluster_preload(cl, &pari, &si);
  14839. +}
  14840. +
  14841. +static struct sk_buff *dect_llme_fill(const struct dect_cluster *cl,
  14842. + const struct dect_llme_req *lreq,
  14843. + u8 op, u8 type,
  14844. + int (*fill)(const struct dect_cluster *,
  14845. + struct sk_buff *, const void *),
  14846. + const void *data)
  14847. +{
  14848. + struct sk_buff *skb;
  14849. + struct nlmsghdr *nlh;
  14850. + struct dectmsg *dm;
  14851. + struct nlattr *nest;
  14852. + u32 seq = lreq ? lreq->nlh.nlmsg_seq : 0;
  14853. + int err = -ENOBUFS;
  14854. +
  14855. + skb = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
  14856. + if (skb == NULL)
  14857. + goto err1;
  14858. +
  14859. + nlh = nlmsg_put(skb, 0, seq, DECT_LLME_MSG, sizeof(*dm), NLMSG_DONE);
  14860. + if (nlh == NULL) {
  14861. + err = -EMSGSIZE;
  14862. + goto err2;
  14863. + }
  14864. +
  14865. + dm = nlmsg_data(nlh);
  14866. + dm->dm_index = cl->index;
  14867. +
  14868. + if (nla_put_u8(skb, DECTA_LLME_OP, op) ||
  14869. + nla_put_u8(skb, DECTA_LLME_TYPE, type))
  14870. + goto nla_put_failure;
  14871. +
  14872. + nest = nla_nest_start(skb, DECTA_LLME_DATA);
  14873. + if (nest == NULL)
  14874. + goto nla_put_failure;
  14875. + if (fill(cl, skb, data) < 0)
  14876. + goto nla_put_failure;
  14877. + nla_nest_end(skb, nest);
  14878. +
  14879. + nlmsg_end(skb, nlh);
  14880. + return skb;
  14881. +
  14882. +nla_put_failure:
  14883. +err2:
  14884. + kfree_skb(skb);
  14885. +err1:
  14886. + return ERR_PTR(err);
  14887. +}
  14888. +
  14889. +static const struct dect_llme_link {
  14890. + struct {
  14891. + int (*doit)(struct dect_cluster *cl, const struct sk_buff *,
  14892. + const struct nlmsghdr *, const struct nlattr *[]);
  14893. + } ops[DECT_LLME_MAX + 1];
  14894. + const struct nla_policy *policy;
  14895. + unsigned int maxtype;
  14896. +} dect_llme_dispatch[DECT_LLME_MAX + 1] = {
  14897. + [DECT_LLME_SCAN] = {
  14898. + .policy = dect_llme_mac_info_policy,
  14899. + .maxtype = DECTA_MAC_INFO_MAX,
  14900. + .ops = {
  14901. + [DECT_LLME_REQUEST].doit = dect_llme_scan_request,
  14902. + },
  14903. + },
  14904. + [DECT_LLME_MAC_INFO] = {
  14905. + .policy = dect_llme_mac_info_policy,
  14906. + .maxtype = DECTA_MAC_INFO_MAX,
  14907. + .ops = {
  14908. + [DECT_LLME_REQUEST].doit = dect_llme_mac_info_req,
  14909. + [DECT_LLME_RESPONSE].doit = dect_llme_mac_info_res,
  14910. + },
  14911. + },
  14912. + [DECT_LLME_MAC_RFP_PRELOAD] = {
  14913. + .policy = dect_llme_mac_info_policy,
  14914. + .maxtype = DECTA_MAC_INFO_MAX,
  14915. + .ops = {
  14916. + [DECT_LLME_REQUEST].doit = dect_llme_mac_rfp_preload,
  14917. + },
  14918. + },
  14919. +};
  14920. +
  14921. +static const struct nla_policy dect_llme_policy[DECTA_LLME_MAX + 1] = {
  14922. + [DECTA_LLME_OP] = { .type = NLA_U8 },
  14923. + [DECTA_LLME_TYPE] = { .type = NLA_U8 },
  14924. + [DECTA_LLME_DATA] = { .type = NLA_NESTED },
  14925. +};
  14926. +
  14927. +static int dect_llme_msg(const struct sk_buff *skb,
  14928. + const struct nlmsghdr *nlh,
  14929. + const struct nlattr *tb[DECTA_LLME_MAX + 1])
  14930. +{
  14931. + const struct dect_llme_link *link;
  14932. + struct dect_cluster *cl;
  14933. + struct dectmsg *dm;
  14934. + enum dect_llme_msg_types type;
  14935. + enum dect_llme_ops op;
  14936. + int err;
  14937. +
  14938. + if (tb[DECTA_LLME_OP] == NULL ||
  14939. + tb[DECTA_LLME_TYPE] == NULL ||
  14940. + tb[DECTA_LLME_DATA] == NULL)
  14941. + return -EINVAL;
  14942. +
  14943. + dm = nlmsg_data(nlh);
  14944. + cl = dect_cluster_get_by_index(dm->dm_index);
  14945. + if (cl == NULL)
  14946. + return -ENODEV;
  14947. +
  14948. + type = nla_get_u8(tb[DECTA_LLME_TYPE]);
  14949. + if (type > DECT_LLME_MAX)
  14950. + return -EINVAL;
  14951. + link = &dect_llme_dispatch[type];
  14952. +
  14953. + op = nla_get_u8(tb[DECTA_LLME_OP]);
  14954. + switch (op) {
  14955. + case DECT_LLME_REQUEST:
  14956. + case DECT_LLME_INDICATE:
  14957. + case DECT_LLME_RESPONSE:
  14958. + case DECT_LLME_CONFIRM:
  14959. + if (link->ops[op].doit == NULL)
  14960. + return -EOPNOTSUPP;
  14961. + break;
  14962. + default:
  14963. + return -EINVAL;
  14964. + }
  14965. +
  14966. + if (1) {
  14967. + struct nlattr *nla[link->maxtype + 1];
  14968. +
  14969. + err = nla_parse_nested(nla, link->maxtype, tb[DECTA_LLME_DATA],
  14970. + link->policy);
  14971. + if (err < 0)
  14972. + return err;
  14973. + return link->ops[op].doit(cl, skb, nlh,
  14974. + (const struct nlattr **)nla);
  14975. + }
  14976. +}
  14977. +
  14978. +/*
  14979. + * Cluster netlink interface
  14980. + */
  14981. +
  14982. +static int dect_cluster_alloc_index(void)
  14983. +{
  14984. + static int index;
  14985. +
  14986. + for (;;) {
  14987. + if (++index <= 0)
  14988. + index = 1;
  14989. + if (!dect_cluster_get_by_index(index))
  14990. + return index;
  14991. + }
  14992. +}
  14993. +
  14994. +static int dect_fill_tb(struct sk_buff *skb, const struct dect_tb *tb)
  14995. +{
  14996. + struct nlattr *nest;
  14997. +
  14998. + nest = nla_nest_start(skb, DECTA_LIST_ELEM);
  14999. + if (nest == NULL)
  15000. + goto nla_put_failure;
  15001. + if (nla_put_u8(skb, DECTA_MBC_TB_LBN, tb->id.lbn) ||
  15002. + nla_put_u8(skb, DECTA_MBC_TB_ECN, tb->id.ecn) ||
  15003. + nla_put_u8(skb, DECTA_MBC_TB_CELL, tb->ch->rpn) ||
  15004. + nla_put_u8(skb, DECTA_MBC_TB_RX_SLOT, tb->rx_slot) ||
  15005. + nla_put_u8(skb, DECTA_MBC_TB_TX_SLOT, tb->tx_slot))
  15006. + goto nla_put_failure;
  15007. + nla_nest_end(skb, nest);
  15008. + return 0;
  15009. +
  15010. +nla_put_failure:
  15011. + return -EMSGSIZE;
  15012. +}
  15013. +
  15014. +static int dect_fill_mbc(struct sk_buff *skb, const struct dect_mbc *mbc)
  15015. +{
  15016. + struct nlattr *nest, *stats, *tbs;
  15017. + struct dect_tb *tb;
  15018. + int err;
  15019. +
  15020. + nest = nla_nest_start(skb, DECTA_LIST_ELEM);
  15021. + if (nest == NULL)
  15022. + goto nla_put_failure;
  15023. + if (nla_put_u32(skb, DECTA_MBC_MCEI, mbc->id.mcei) ||
  15024. + nla_put_u8(skb, DECTA_MBC_SERVICE, mbc->mcp.service) ||
  15025. + nla_put_u8(skb, DECTA_MBC_STATE, mbc->state) ||
  15026. + nla_put_u8(skb, DECTA_MBC_CIPHER_STATE, mbc->cipher_state))
  15027. + goto nla_put_failure;
  15028. +
  15029. + stats = nla_nest_start(skb, DECTA_MBC_STATS);
  15030. + if (stats == NULL)
  15031. + goto nla_put_failure;
  15032. + if (nla_put_u32(skb, DECTA_MBC_STATS_CS_RX_BYTES,
  15033. + mbc->stats.cs_rx_bytes) ||
  15034. + nla_put_u32(skb, DECTA_MBC_STATS_CS_TX_BYTES,
  15035. + mbc->stats.cs_tx_bytes) ||
  15036. + nla_put_u32(skb, DECTA_MBC_STATS_I_RX_BYTES,
  15037. + mbc->stats.i_rx_bytes) ||
  15038. + nla_put_u32(skb, DECTA_MBC_STATS_I_TX_BYTES,
  15039. + mbc->stats.i_tx_bytes) ||
  15040. + nla_put_u32(skb, DECTA_MBC_STATS_HANDOVERS,
  15041. + mbc->stats.handovers))
  15042. + goto nla_put_failure;
  15043. + nla_nest_end(skb, stats);
  15044. +
  15045. + tbs = nla_nest_start(skb, DECTA_MBC_TBS);
  15046. + if (tbs == NULL)
  15047. + goto nla_put_failure;
  15048. + list_for_each_entry(tb, &mbc->tbs, list) {
  15049. + err = dect_fill_tb(skb, tb);
  15050. + if (err < 0)
  15051. + goto nla_put_failure;
  15052. + }
  15053. + nla_nest_end(skb, tbs);
  15054. + nla_nest_end(skb, nest);
  15055. + return 0;
  15056. +
  15057. +nla_put_failure:
  15058. + return -EMSGSIZE;
  15059. +}
  15060. +
  15061. +static int dect_fill_cluster(struct sk_buff *skb,
  15062. + const struct dect_cluster *cl,
  15063. + u16 type, u32 portid, u32 seq, u16 flags)
  15064. +{
  15065. + struct nlmsghdr *nlh;
  15066. + struct dectmsg *dm;
  15067. + struct nlattr *nest;
  15068. + struct dect_cell_handle *ch;
  15069. + struct dect_mbc *mbc;
  15070. +
  15071. + nlh = nlmsg_put(skb, portid, seq, type, sizeof(*dm), flags);
  15072. + if (nlh == NULL)
  15073. + return -EMSGSIZE;
  15074. +
  15075. + dm = nlmsg_data(nlh);
  15076. + dm->dm_index = cl->index;
  15077. + if (nla_put_string(skb, DECTA_CLUSTER_NAME, cl->name) ||
  15078. + nla_put_u8(skb, DECTA_CLUSTER_MODE, cl->mode) ||
  15079. + dect_fill_ari(skb, &cl->pari, DECTA_CLUSTER_PARI) < 0)
  15080. + goto nla_put_failure;
  15081. +
  15082. + if (!list_empty(&cl->cells)) {
  15083. + nest = nla_nest_start(skb, DECTA_CLUSTER_CELLS);
  15084. + if (nest == NULL)
  15085. + goto nla_put_failure;
  15086. + list_for_each_entry(ch, &cl->cells, list)
  15087. + if (nla_put_u8(skb, DECTA_LIST_ELEM, ch->rpn))
  15088. + goto nla_put_failure;
  15089. + nla_nest_end(skb, nest);
  15090. + }
  15091. +
  15092. + if (!list_empty(&cl->mbcs)) {
  15093. + nest = nla_nest_start(skb, DECTA_CLUSTER_MBCS);
  15094. + if (nest == NULL)
  15095. + goto nla_put_failure;
  15096. +
  15097. + list_for_each_entry(mbc, &cl->mbcs, list)
  15098. + if (dect_fill_mbc(skb, mbc) < 0)
  15099. + goto nla_put_failure;
  15100. +
  15101. + nla_nest_end(skb, nest);
  15102. + }
  15103. +
  15104. + nlmsg_end(skb, nlh);
  15105. + return skb->len;
  15106. +
  15107. +nla_put_failure:
  15108. + nlmsg_cancel(skb, nlh);
  15109. + return -EMSGSIZE;
  15110. +}
  15111. +
  15112. +static int dect_dump_cluster(struct sk_buff *skb,
  15113. + struct netlink_callback *cb)
  15114. +{
  15115. + const struct dect_cluster *cl;
  15116. + unsigned int idx, s_idx;
  15117. +
  15118. + s_idx = cb->args[0];
  15119. + idx = 0;
  15120. + list_for_each_entry(cl, &dect_cluster_list, list) {
  15121. + if (idx < s_idx)
  15122. + goto cont;
  15123. + if (dect_fill_cluster(skb, cl, DECT_NEW_CLUSTER,
  15124. + NETLINK_CB(cb->skb).portid,
  15125. + cb->nlh->nlmsg_seq, NLM_F_MULTI) <= 0)
  15126. + break;
  15127. +cont:
  15128. + idx++;
  15129. + }
  15130. + cb->args[0] = idx;
  15131. +
  15132. + return skb->len;
  15133. +}
  15134. +
  15135. +static void dect_notify_cluster(u16 event, const struct dect_cluster *cl,
  15136. + const struct nlmsghdr *nlh, u32 portid)
  15137. +{
  15138. + struct sk_buff *skb;
  15139. + bool report = nlh ? nlmsg_report(nlh) : 0;
  15140. + u32 seq = nlh ? nlh->nlmsg_seq : 0;
  15141. + int err = -ENOBUFS;
  15142. +
  15143. + skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
  15144. + if (skb == NULL)
  15145. + goto err;
  15146. +
  15147. + err = dect_fill_cluster(skb, cl, event, portid, seq, NLMSG_DONE);
  15148. + if (err < 0) {
  15149. + WARN_ON(err == -EMSGSIZE);
  15150. + kfree_skb(skb);
  15151. + goto err;
  15152. + }
  15153. + nlmsg_notify(dect_nlsk, skb, portid, DECTNLGRP_CLUSTER, report,
  15154. + GFP_KERNEL);
  15155. +err:
  15156. + if (err < 0)
  15157. + netlink_set_err(dect_nlsk, portid, DECTNLGRP_CLUSTER, err);
  15158. +}
  15159. +
  15160. +static const struct nla_policy dect_cluster_policy[DECTA_CLUSTER_MAX + 1] = {
  15161. + [DECTA_CLUSTER_NAME] = { .type = NLA_STRING, .len = DECTNAMSIZ },
  15162. + [DECTA_CLUSTER_MODE] = { .type = NLA_U8 },
  15163. + [DECTA_CLUSTER_PARI] = { .len = NLA_NESTED },
  15164. +};
  15165. +
  15166. +static int dect_new_cluster(const struct sk_buff *skb,
  15167. + const struct nlmsghdr *nlh,
  15168. + const struct nlattr *tb[DECTA_CLUSTER_MAX + 1])
  15169. +{
  15170. + struct dect_cluster *cl;
  15171. + struct dect_ari pari;
  15172. + enum dect_cluster_modes uninitialized_var(mode);
  15173. + int err;
  15174. +
  15175. + if (tb[DECTA_CLUSTER_NAME] == NULL)
  15176. + return -EINVAL;
  15177. +
  15178. + if (tb[DECTA_CLUSTER_MODE] != NULL) {
  15179. + mode = nla_get_u8(tb[DECTA_CLUSTER_MODE]);
  15180. + switch (mode) {
  15181. + case DECT_MODE_FP:
  15182. + case DECT_MODE_PP:
  15183. + break;
  15184. + default:
  15185. + return -EINVAL;
  15186. + }
  15187. + }
  15188. +
  15189. + if (tb[DECTA_CLUSTER_PARI] != NULL) {
  15190. + err = dect_nla_parse_ari(&pari, tb[DECTA_CLUSTER_PARI]);
  15191. + if (err < 0)
  15192. + return err;
  15193. + }
  15194. +
  15195. + cl = dect_cluster_get_by_name(tb[DECTA_CLUSTER_NAME]);
  15196. + if (cl != NULL) {
  15197. + if (nlh->nlmsg_flags & NLM_F_EXCL)
  15198. + return -EEXIST;
  15199. +
  15200. + return 0;
  15201. + }
  15202. +
  15203. + if (!(nlh->nlmsg_flags & NLM_F_CREATE))
  15204. + return -ENOENT;
  15205. +
  15206. + if (tb[DECTA_CLUSTER_MODE] == NULL)
  15207. + return -EINVAL;
  15208. +
  15209. + cl = kzalloc(sizeof(*cl), GFP_KERNEL);
  15210. + if (cl == NULL)
  15211. + return -ENOMEM;
  15212. + nla_strlcpy(cl->name, tb[DECTA_CLUSTER_NAME], sizeof(cl->name));
  15213. +
  15214. + memcpy(&cl->pari, &pari, sizeof(cl->pari));
  15215. + cl->index = dect_cluster_alloc_index();
  15216. + cl->mode = mode;
  15217. +
  15218. + err = dect_cluster_init(cl);
  15219. + if (err < 0)
  15220. + goto err1;
  15221. +
  15222. + list_add_tail(&cl->list, &dect_cluster_list);
  15223. + dect_notify_cluster(DECT_NEW_CLUSTER, cl, nlh, NETLINK_CB(skb).portid);
  15224. + return 0;
  15225. +
  15226. +err1:
  15227. + kfree(cl);
  15228. + return err;
  15229. +}
  15230. +
  15231. +static int dect_del_cluster(const struct sk_buff *skb,
  15232. + const struct nlmsghdr *nlh,
  15233. + const struct nlattr *tb[DECTA_CLUSTER_MAX + 1])
  15234. +{
  15235. + struct dect_cluster *cl;
  15236. + struct dectmsg *dm;
  15237. +
  15238. + dm = nlmsg_data(nlh);
  15239. + if (dm->dm_index != 0)
  15240. + cl = dect_cluster_get_by_index(dm->dm_index);
  15241. + else if (tb[DECTA_CLUSTER_NAME] != NULL)
  15242. + cl = dect_cluster_get_by_name(tb[DECTA_CLUSTER_NAME]);
  15243. + else
  15244. + return -EINVAL;
  15245. + if (cl == NULL)
  15246. + return -ENODEV;
  15247. +
  15248. + dect_cluster_shutdown(cl);
  15249. + list_del(&cl->list);
  15250. +
  15251. + dect_notify_cluster(DECT_DEL_CLUSTER, cl, nlh, NETLINK_CB(skb).portid);
  15252. + kfree(cl);
  15253. + return 0;
  15254. +}
  15255. +
  15256. +static int dect_get_cluster(const struct sk_buff *in_skb,
  15257. + const struct nlmsghdr *nlh,
  15258. + const struct nlattr *tb[DECTA_CLUSTER_MAX + 1])
  15259. +{
  15260. + u32 portid = NETLINK_CB(in_skb).portid;
  15261. + const struct dect_cluster *cl;
  15262. + struct dectmsg *dm;
  15263. + struct sk_buff *skb;
  15264. + int err;
  15265. +
  15266. + dm = nlmsg_data(nlh);
  15267. + if (dm->dm_index != 0)
  15268. + cl = dect_cluster_get_by_index(dm->dm_index);
  15269. + else if (tb[DECTA_CLUSTER_NAME] != NULL)
  15270. + cl = dect_cluster_get_by_name(tb[DECTA_CLUSTER_NAME]);
  15271. + else
  15272. + return -EINVAL;
  15273. + if (cl == NULL)
  15274. + return -ENODEV;
  15275. +
  15276. + skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
  15277. + if (skb == NULL)
  15278. + return -ENOMEM;
  15279. + err = dect_fill_cluster(skb, cl, DECT_NEW_CLUSTER, portid,
  15280. + nlh->nlmsg_seq, NLMSG_DONE);
  15281. + if (err < 0)
  15282. + goto err1;
  15283. + return nlmsg_unicast(dect_nlsk, skb, portid);
  15284. +
  15285. +err1:
  15286. + kfree_skb(skb);
  15287. + return err;
  15288. +}
  15289. +
  15290. +static const struct dect_netlink_handler dect_cluster_handlers[] = {
  15291. + {
  15292. + /* DECT_NEW_CLUSTER */
  15293. + .policy = dect_cluster_policy,
  15294. + .maxtype = DECTA_CLUSTER_MAX,
  15295. + .doit = dect_new_cluster,
  15296. + },
  15297. + {
  15298. + /* DECT_DEL_CLUSTER */
  15299. + .policy = dect_cluster_policy,
  15300. + .maxtype = DECTA_CLUSTER_MAX,
  15301. + .doit = dect_del_cluster,
  15302. + },
  15303. + {
  15304. + /* DECT_GET_CLUSTER */
  15305. + .policy = dect_cluster_policy,
  15306. + .maxtype = DECTA_CLUSTER_MAX,
  15307. + .doit = dect_get_cluster,
  15308. + .dump = dect_dump_cluster,
  15309. + },
  15310. + {
  15311. + /* DECT_LLME_MSG */
  15312. + .policy = dect_llme_policy,
  15313. + .maxtype = DECTA_LLME_MAX,
  15314. + .doit = dect_llme_msg,
  15315. + },
  15316. +};
  15317. +
  15318. +static int __init dect_ccf_module_init(void)
  15319. +{
  15320. + int err;
  15321. +
  15322. + err = dect_bsap_module_init();
  15323. + if (err < 0)
  15324. + goto err1;
  15325. +
  15326. + err = dect_ssap_module_init();
  15327. + if (err < 0)
  15328. + goto err2;
  15329. +
  15330. + dect_netlink_register_handlers(dect_cluster_handlers, DECT_NEW_CLUSTER,
  15331. + ARRAY_SIZE(dect_cluster_handlers));
  15332. +
  15333. + return 0;
  15334. +
  15335. +err2:
  15336. + dect_bsap_module_exit();
  15337. +err1:
  15338. + return err;
  15339. +}
  15340. +
  15341. +static void __exit dect_ccf_module_exit(void)
  15342. +{
  15343. + dect_netlink_unregister_handlers(DECT_NEW_CLUSTER,
  15344. + ARRAY_SIZE(dect_cluster_handlers));
  15345. + dect_bsap_module_exit();
  15346. + dect_ssap_module_exit();
  15347. +}
  15348. +
  15349. +module_init(dect_ccf_module_init);
  15350. +module_exit(dect_ccf_module_exit);
  15351. +MODULE_LICENSE("GPL");
  15352. diff --git a/net/dect/mac_csf.c b/net/dect/mac_csf.c
  15353. new file mode 100644
  15354. index 0000000..dc98e94
  15355. --- /dev/null
  15356. +++ b/net/dect/mac_csf.c
  15357. @@ -0,0 +1,5357 @@
  15358. +/*
  15359. + * DECT MAC Cell Site Functions
  15360. + *
  15361. + * Copyright (c) 2009-2011 Patrick McHardy <[email protected]>
  15362. + *
  15363. + * This program is free software; you can redistribute it and/or modify
  15364. + * it under the terms of the GNU General Public License version 2 as
  15365. + * published by the Free Software Foundation.
  15366. + */
  15367. +
  15368. +#ifdef CONFIG_DECT_DEBUG
  15369. +#define DEBUG
  15370. +#endif
  15371. +
  15372. +#include <linux/kernel.h>
  15373. +#include <linux/module.h>
  15374. +#include <linux/init.h>
  15375. +#include <linux/list.h>
  15376. +#include <linux/skbuff.h>
  15377. +#include <linux/net.h>
  15378. +#include <linux/dect.h>
  15379. +#include <net/dect/dect.h>
  15380. +#include <net/dect/mac_csf.h>
  15381. +#include <net/dect/ccp.h>
  15382. +
  15383. +/* avoid <KERN_DEBUG> for continuation lines */
  15384. +#undef KERN_DEBUG
  15385. +#define KERN_DEBUG
  15386. +
  15387. +static void dect_notify_cell(u16 event, const struct dect_cell *cell,
  15388. + const struct nlmsghdr *nlh, u32 portid);
  15389. +static void dect_cell_schedule_page(struct dect_cell *cell, u32 mask);
  15390. +
  15391. +static const u8 dect_fp_preamble[] = { 0x55, 0x55, 0xe9, 0x8a};
  15392. +static const u8 dect_pp_preamble[] = { 0xaa, 0xaa, 0x16, 0x75};
  15393. +
  15394. +static const u8 dect_pkt_b_field_sizes[] = {
  15395. + [DECT_PACKET_P00] = 0,
  15396. + [DECT_PACKET_P32] = 40,
  15397. + [DECT_PACKET_P640j] = 80,
  15398. + [DECT_PACKET_P80] = 100,
  15399. +};
  15400. +
  15401. +static u8 dect_pkt_b_field_size(const struct dect_channel_desc *chd)
  15402. +{
  15403. + return dect_pkt_b_field_sizes[chd->pkt];
  15404. +}
  15405. +
  15406. +#define mac_debug(cell, base, fmt, args...) \
  15407. + pr_debug("%s %u.%.2u.%.2u: " fmt, \
  15408. + (base) == DECT_TIMER_TX ? "TX" : "RX", \
  15409. + cell->timer_base[(base)].mfn, cell->timer_base[(base)].framenum, \
  15410. + cell->timer_base[(base)].slot, ## args)
  15411. +
  15412. +#define rx_debug(cell, fmt, args...) \
  15413. + mac_debug(cell, DECT_TIMER_RX, fmt, ## args)
  15414. +#define tx_debug(cell, fmt, args...) \
  15415. + mac_debug(cell, DECT_TIMER_TX, fmt, ## args)
  15416. +
  15417. +static LIST_HEAD(dect_cell_list);
  15418. +
  15419. +struct dect_cell *dect_cell_get_by_index(u32 index)
  15420. +{
  15421. + struct dect_cell *cell;
  15422. +
  15423. + list_for_each_entry(cell, &dect_cell_list, list) {
  15424. + if (cell->index == index)
  15425. + return cell;
  15426. + }
  15427. + return NULL;
  15428. +}
  15429. +EXPORT_SYMBOL_GPL(dect_cell_get_by_index);
  15430. +
  15431. +static struct dect_cell *dect_cell_get_by_name(const struct nlattr *nla)
  15432. +{
  15433. + struct dect_cell *cell;
  15434. +
  15435. + list_for_each_entry(cell, &dect_cell_list, list) {
  15436. + if (!nla_strcmp(nla, cell->name))
  15437. + return cell;
  15438. + }
  15439. + return NULL;
  15440. +}
  15441. +
  15442. +static struct dect_cell *dect_cell(const struct dect_cell_handle *ch)
  15443. +{
  15444. + return container_of(ch, struct dect_cell, handle);
  15445. +}
  15446. +
  15447. +/*
  15448. + * MAC CSF layer timers
  15449. + */
  15450. +
  15451. +#if 0
  15452. +#define timer_debug(cell, base, fmt, args...) \
  15453. + mac_debug(cell, base, fmt, ## args)
  15454. +#else
  15455. +#define timer_debug(cell, base, fmt, args...)
  15456. +#endif
  15457. +
  15458. +static u8 dect_slotnum(const struct dect_cell *cell, enum dect_timer_bases b)
  15459. +{
  15460. + return __dect_slotnum(&cell->timer_base[b]);
  15461. +}
  15462. +
  15463. +static u8 dect_framenum(const struct dect_cell *cell, enum dect_timer_bases b)
  15464. +{
  15465. + return __dect_framenum(&cell->timer_base[b]);
  15466. +}
  15467. +
  15468. +static u32 dect_mfn(const struct dect_cell *cell, enum dect_timer_bases b)
  15469. +{
  15470. + return __dect_mfn(&cell->timer_base[b]);
  15471. +}
  15472. +
  15473. +/* Return whether the TX time is in the next frame relative to the RX time */
  15474. +static bool dect_tx_time_wrapped(const struct dect_cell *cell)
  15475. +{
  15476. + return dect_slotnum(cell, DECT_TIMER_TX) <
  15477. + dect_slotnum(cell, DECT_TIMER_RX);
  15478. +}
  15479. +
  15480. +/**
  15481. + * dect_timer_synchronize_framenum
  15482. + *
  15483. + * Synchronize the current frame number based on Q-channel reception.
  15484. + *
  15485. + * Q-channel information is transmitted only in frame 8 and serves as an
  15486. + * indirect indication. The TX frame number update needs to take the clock
  15487. + * difference into account.
  15488. + */
  15489. +static void dect_timer_synchronize_framenum(struct dect_cell *cell, u8 framenum)
  15490. +{
  15491. + cell->timer_base[DECT_TIMER_RX].framenum = framenum;
  15492. + if (dect_tx_time_wrapped(cell))
  15493. + framenum++;
  15494. + cell->timer_base[DECT_TIMER_TX].framenum = framenum;
  15495. +}
  15496. +
  15497. +static void dect_timer_synchronize_mfn(struct dect_cell *cell, u32 mfn)
  15498. +{
  15499. + cell->timer_base[DECT_TIMER_RX].mfn = mfn;
  15500. + cell->timer_base[DECT_TIMER_TX].mfn = mfn;
  15501. + cell->timer_sync_stamp = mfn;
  15502. +}
  15503. +
  15504. +static void dect_run_timers(struct dect_cell *cell, enum dect_timer_bases b)
  15505. +{
  15506. + __dect_run_timers(cell->name, &cell->timer_base[b]);
  15507. +}
  15508. +
  15509. +static void dect_timer_base_update(struct dect_cell *cell,
  15510. + enum dect_timer_bases b, u8 slot)
  15511. +{
  15512. + struct dect_timer_base *base = &cell->timer_base[b];
  15513. +
  15514. + base->slot = slot;
  15515. + if (base->slot == 0) {
  15516. + base->framenum = dect_next_framenum(base->framenum);
  15517. + if (base->framenum == 0)
  15518. + base->mfn = dect_next_mfn(base->mfn);
  15519. + }
  15520. + timer_debug(cell, base, "update time base\n");
  15521. +}
  15522. +
  15523. +/**
  15524. + * dect_timer_add - (re)schedule a timer
  15525. + *
  15526. + * Frame numbers are relative to the current time, slot positions are absolute.
  15527. + * A timer scheduled for (1, 2) will expire in slot 2 in the next frame.
  15528. + *
  15529. + * A frame number of zero will expire at the next occurence of the slot, which
  15530. + * can be within the same frame in case the slot is not already in the past, or
  15531. + * in the next frame in case it is.
  15532. + */
  15533. +static void dect_timer_add(struct dect_cell *cell, struct dect_timer *timer,
  15534. + enum dect_timer_bases base, u32 frame, u8 slot)
  15535. +{
  15536. + timer->cell = cell;
  15537. + __dect_timer_add(cell->name, &cell->timer_base[base], timer, frame, slot);
  15538. +}
  15539. +
  15540. +static void dect_timer_setup(struct dect_timer *timer,
  15541. + void (*func)(struct dect_cell *, void *),
  15542. + void *data)
  15543. +{
  15544. + dect_timer_init(timer);
  15545. + timer->cb.cell = func;
  15546. + timer->data = data;
  15547. +}
  15548. +
  15549. +/*
  15550. + * Basic Channel lists
  15551. + *
  15552. + * A channel list contains channel descriptions of all physical channels
  15553. + * able to carry the packet type, sorted into multiple bins based on the
  15554. + * maximum RSSI value of the TDD slot pair.
  15555. + *
  15556. + * At any time, only a single incomplete channel list exists that is updated
  15557. + * based on the RSSI measurements gathered by the individual IRC instances.
  15558. + * Once a list is complete, it is added to the list of active channel lists,
  15559. + * replacing the previous one for the same packet type, if any.
  15560. + */
  15561. +
  15562. +#if 1
  15563. +#define chl_debug(cell, chl, fmt, args...) \
  15564. + rx_debug(cell, "channel-list %s (%u): " fmt, \
  15565. + (chl)->pkt == DECT_PACKET_P00 ? "P00" : \
  15566. + (chl)->pkt == DECT_PACKET_P08 ? "P08" : \
  15567. + (chl)->pkt == DECT_PACKET_P32 ? "P32" : \
  15568. + (chl)->pkt == DECT_PACKET_P640j ? "P640j" : \
  15569. + (chl)->pkt == DECT_PACKET_P672j ? "P672j" : "?", \
  15570. + (chl)->available, ## args)
  15571. +#else
  15572. +#define chl_debug(cell, chl, fmt, args...)
  15573. +#endif
  15574. +
  15575. +static int dect_chl_schedule_update(struct dect_cell *cell,
  15576. + enum dect_packet_types pkt);
  15577. +
  15578. +static struct dect_channel_list *dect_chl_lookup(const struct dect_cell *cell,
  15579. + enum dect_packet_types pkt)
  15580. +{
  15581. + struct dect_channel_list *chl;
  15582. +
  15583. + list_for_each_entry(chl, &cell->chanlists, list) {
  15584. + if (chl->pkt == pkt)
  15585. + return chl;
  15586. + }
  15587. + return NULL;
  15588. +}
  15589. +
  15590. +static void dect_chl_timer(struct dect_cell *cell, void *data)
  15591. +{
  15592. + struct dect_channel_list *chl = data;
  15593. +
  15594. + if (dect_chl_schedule_update(cell, chl->pkt) < 0)
  15595. + dect_timer_add(cell, &chl->timer, DECT_TIMER_RX, 1, 0);
  15596. +}
  15597. +
  15598. +static void dect_chl_release(struct dect_channel_list *chl)
  15599. +{
  15600. + dect_timer_del(&chl->timer);
  15601. + kfree(chl);
  15602. +}
  15603. +
  15604. +static struct dect_channel_list *dect_chl_init(struct dect_cell *cell,
  15605. + enum dect_packet_types pkt)
  15606. +{
  15607. + struct dect_channel_list *chl;
  15608. + unsigned int entries, i;
  15609. +
  15610. + entries = DECT_CARRIER_NUM * DECT_HALF_FRAME_SIZE;
  15611. + chl = kzalloc(sizeof(*chl) + entries * sizeof(chl->entries[0]), GFP_ATOMIC);
  15612. + if (chl == NULL)
  15613. + return NULL;
  15614. + chl->pkt = pkt;
  15615. + dect_timer_setup(&chl->timer, dect_chl_timer, chl);
  15616. + for (i = 0; i < ARRAY_SIZE(chl->bins); i++)
  15617. + INIT_LIST_HEAD(&chl->bins[i]);
  15618. + for (i = 0; i < entries; i++)
  15619. + INIT_LIST_HEAD(&chl->entries[i].list);
  15620. + return chl;
  15621. +}
  15622. +
  15623. +static int dect_chl_schedule_update(struct dect_cell *cell,
  15624. + enum dect_packet_types pkt)
  15625. +{
  15626. + struct dect_channel_list *chl;
  15627. +
  15628. + list_for_each_entry(chl, &cell->chl_pending, list) {
  15629. + if (chl->pkt == pkt)
  15630. + return 0;
  15631. + }
  15632. +
  15633. + chl = dect_chl_init(cell, pkt);
  15634. + if (chl == NULL)
  15635. + return -ENOMEM;
  15636. + chl_debug(cell, chl, "schedule update\n");
  15637. + list_add_tail(&chl->list, &cell->chl_pending);
  15638. + return 0;
  15639. +}
  15640. +
  15641. +static struct dect_channel_list *dect_chl_get_pending(struct dect_cell *cell)
  15642. +{
  15643. + struct dect_channel_list *chl;
  15644. +
  15645. + if (list_empty(&cell->chl_pending))
  15646. + return NULL;
  15647. + chl = list_first_entry(&cell->chl_pending,
  15648. + struct dect_channel_list,
  15649. + list);
  15650. + list_del(&chl->list);
  15651. + return chl;
  15652. +}
  15653. +
  15654. +static void dect_chl_update(struct dect_cell *cell,
  15655. + struct dect_channel_list *chl,
  15656. + const struct dect_channel_desc *chd, u8 rssi)
  15657. +{
  15658. + struct dect_channel_list_entry *e;
  15659. + u8 slot, bin;
  15660. +
  15661. + if (rssi > dect_dbm_to_rssi(DECT_CHANNEL_LIST_MAX_DBM)) {
  15662. + chl_debug(cell, chl, "carrier %u slot %u: too much noise: RSSI %u\n",
  15663. + chd->carrier, chd->slot, rssi);
  15664. + return;
  15665. + }
  15666. +
  15667. + slot = chd->slot < 12 ? chd->slot : chd->slot - 12;
  15668. + chl_debug(cell, chl, "update carrier %u slot %u pos %u RSSI %u\n",
  15669. + chd->carrier, chd->slot, slot, rssi);
  15670. +
  15671. + e = &chl->entries[chd->carrier * DECT_HALF_FRAME_SIZE + slot];
  15672. + if (!list_empty(&e->list))
  15673. + return;
  15674. +
  15675. + if (chd->slot < DECT_HALF_FRAME_SIZE) {
  15676. + e->slot = slot;
  15677. + e->carrier = chd->carrier;
  15678. + e->rssi = rssi;
  15679. + } else if (e->rssi != 0) {
  15680. + e->rssi = max(e->rssi, rssi);
  15681. + bin = rssi * ARRAY_SIZE(chl->bins) / (DECT_RSSI_RANGE + 1);
  15682. +
  15683. + list_add_tail(&e->list, &chl->bins[bin]);
  15684. + chl->available++;
  15685. + }
  15686. +}
  15687. +
  15688. +static void dect_chl_update_carrier(struct dect_cell *cell, u8 carrier)
  15689. +{
  15690. + struct dect_channel_list *chl, *old;
  15691. +
  15692. + chl = cell->chl;
  15693. + chl_debug(cell, chl, "update status %03llx rfcars %03x carrier %u\n",
  15694. + (unsigned long long)chl->status, cell->si.ssi.rfcars, carrier);
  15695. +
  15696. + chl->status |= 1ULL << carrier;
  15697. + if (chl->status != cell->si.ssi.rfcars)
  15698. + return;
  15699. + cell->chl = NULL;
  15700. +
  15701. + chl_debug(cell, chl, "complete %u entries\n", chl->available);
  15702. + old = dect_chl_lookup(cell, chl->pkt);
  15703. + if (old != NULL) {
  15704. + list_del(&old->list);
  15705. + dect_chl_release(old);
  15706. + }
  15707. +
  15708. + dect_timer_add(cell, &chl->timer, DECT_TIMER_RX,
  15709. + DECT_CHANNEL_LIST_MAX_AGE * 2 / 3 *
  15710. + DECT_FRAMES_PER_SECOND, 0);
  15711. + list_add_tail(&chl->list, &cell->chanlists);
  15712. +}
  15713. +
  15714. +static void dect_chl_flush(struct dect_cell *cell)
  15715. +{
  15716. + struct dect_channel_list *chl, *next;
  15717. +
  15718. + list_for_each_entry_safe(chl, next, &cell->chanlists, list) {
  15719. + list_del(&chl->list);
  15720. + dect_chl_release(chl);
  15721. + }
  15722. +}
  15723. +
  15724. +/**
  15725. + * dect_channel_delay - calculate delay in frames until a channel is accessible
  15726. + *
  15727. + * Calculate the delay in frames until one of the remote sides' scans is on the
  15728. + * specified carrier.
  15729. + *
  15730. + * A FP maintains one to three scans, which lag behind each other by three
  15731. + * carriers, a PP maintains zero or one (fast-setup) scan. The PP fast-
  15732. + * setup scan leads the FP primary scan by one carrier.
  15733. + *
  15734. + * Setup needs at least one full frame, therefore a scan reaching a carrier
  15735. + * earlier than that must be treated as reachable one cycle later.
  15736. + */
  15737. +static u8 dect_channel_delay(const struct dect_cell *cell,
  15738. + const struct dect_channel_desc *chd)
  15739. +{
  15740. + u64 rfcars = cell->si.ssi.rfcars;
  15741. + u8 i, txs, scn, frames;
  15742. + s8 d;
  15743. +
  15744. + if (cell->mode == DECT_MODE_FP) {
  15745. + /* PP fast-setup scan */
  15746. + scn = dect_next_carrier(rfcars, cell->si.ssi.pscn);
  15747. + txs = 1;
  15748. + } else {
  15749. + /* FP primary scan */
  15750. + scn = dect_prev_carrier(rfcars, cell->si.ssi.pscn);
  15751. + txs = min(cell->si.ssi.txs + 1, 3);
  15752. + }
  15753. +
  15754. + frames = ~0;
  15755. + for (i = 0; i < txs; i++) {
  15756. + d = dect_carrier_distance(rfcars, scn, chd->carrier);
  15757. + /* More than two frames in the future? */
  15758. + if (d <= DECT_CHANNEL_MIN_DELAY)
  15759. + d += hweight64(rfcars);
  15760. +
  15761. + frames = min_t(u8, frames, d);
  15762. + pr_debug("rfcars %llx distance %u->%u slot %u: %u frames %u\n",
  15763. + (unsigned long long)rfcars, scn, chd->carrier,
  15764. + chd->slot, d, frames);
  15765. +
  15766. + scn = dect_carrier_sub(rfcars, scn, 3);
  15767. + }
  15768. +
  15769. + return frames;
  15770. +}
  15771. +
  15772. +static void dect_update_blind_full_slots(struct dect_cell *cell)
  15773. +{
  15774. + u16 bfs;
  15775. +
  15776. + bfs = ~(cell->trg.blind_full_slots | (cell->trg.blind_full_slots >> 12));
  15777. + cell->trg_blind_full_slots = bfs & ((1 << DECT_HALF_FRAME_SIZE) - 1);
  15778. +
  15779. + dect_cell_schedule_page(cell, 1 << DECT_TM_TYPE_BFS);
  15780. +}
  15781. +
  15782. +/**
  15783. + * dect_channel_reserve - reserve a channel on a transceiver
  15784. + *
  15785. + * Reserve the specified transceiver and schedule a blind-full-slots
  15786. + * page message if the visibility state changed.
  15787. + */
  15788. +static void dect_channel_reserve(struct dect_cell *cell,
  15789. + struct dect_transceiver *trx,
  15790. + const struct dect_channel_desc *chd)
  15791. +{
  15792. + if (!dect_transceiver_reserve(&cell->trg, trx, chd))
  15793. + return;
  15794. +
  15795. + dect_update_blind_full_slots(cell);
  15796. +}
  15797. +
  15798. +/**
  15799. + * dect_channel_release - release a channel on a transceiver
  15800. + *
  15801. + * Release the specified transceiver and schedule a blind-full-slots
  15802. + * page message if the visibility state changed.
  15803. + */
  15804. +static void dect_channel_release(struct dect_cell *cell,
  15805. + struct dect_transceiver *trx,
  15806. + const struct dect_channel_desc *chd)
  15807. +{
  15808. + if (!dect_transceiver_release(&cell->trg, trx, chd))
  15809. + return;
  15810. +
  15811. + dect_update_blind_full_slots(cell);
  15812. +}
  15813. +
  15814. +/**
  15815. + * dect_select_transceiver - select a transceiver for placing a bearer
  15816. + *
  15817. + * Select the lowest order transceiver that is able to operate on a physical
  15818. + * channel.
  15819. + */
  15820. +static struct dect_transceiver *
  15821. +dect_select_transceiver(const struct dect_cell *cell,
  15822. + const struct dect_channel_desc *chd)
  15823. +{
  15824. + struct dect_transceiver *trx;
  15825. +
  15826. + dect_foreach_transceiver_reverse(trx, &cell->trg) {
  15827. + if (trx->state != DECT_TRANSCEIVER_LOCKED)
  15828. + continue;
  15829. + if (!dect_transceiver_channel_available(trx, chd))
  15830. + continue;
  15831. + return trx;
  15832. + }
  15833. + return NULL;
  15834. +}
  15835. +
  15836. +/**
  15837. + * dect_select_channel - select a physical channel for bearer setup
  15838. + *
  15839. + * @cell: DECT cell
  15840. + * @trx: selected transceiver
  15841. + * @chd: channel description
  15842. + * @rssi: last measure RSSI value of selected channel
  15843. + * @quick: prefer quickly accessible channel
  15844. + *
  15845. + * This performs the common steps of channel selection based on channel lists.
  15846. + * In "quick" mode, the selected channel is the first channel accessible within
  15847. + * three TDMA frames from the lowest three available bands. When not in quick
  15848. + * mode or when no channel is accessible within three frames, the first
  15849. + * available channel from the lowest available band is selected.
  15850. + *
  15851. + * "quick" mode is used for setting up pilot bearers and for bearer handover.
  15852. + *
  15853. + * The returned channel description is within the normal transmit half
  15854. + * of the cell's mode.
  15855. + */
  15856. +static int dect_select_channel(struct dect_cell *cell,
  15857. + struct dect_transceiver **trxp,
  15858. + struct dect_channel_desc *chd, u8 *rssi,
  15859. + bool quick)
  15860. +{
  15861. + struct dect_channel_list_entry *e, *sel;
  15862. + struct dect_channel_list *chl;
  15863. + struct dect_transceiver *trx, *uninitialized_var(tsel);
  15864. + u8 bin, first, last;
  15865. +
  15866. + chl = dect_chl_lookup(cell, chd->pkt);
  15867. + if (chl == NULL)
  15868. + return -ENOENT;
  15869. +
  15870. + /* Find first non-empty bin */
  15871. + for (first = 0; first < ARRAY_SIZE(chl->bins); first++) {
  15872. + if (!list_empty(&chl->bins[first]))
  15873. + break;
  15874. + }
  15875. + if (first == ARRAY_SIZE(chl->bins))
  15876. + return -ENOSPC;
  15877. +
  15878. + sel = NULL;
  15879. +retry:
  15880. + last = max_t(u8, first + quick ? 3 : 1, ARRAY_SIZE(chl->bins));
  15881. + for (bin = first; sel == NULL && bin < last; bin++) {
  15882. + list_for_each_entry(e, &chl->bins[bin], list) {
  15883. + u8 n = DECT_HALF_FRAME_SIZE - 1 - e->slot;
  15884. +
  15885. + if (!(cell->trg_blind_full_slots & (1 << n)))
  15886. + continue;
  15887. +
  15888. + if (cell->mode == DECT_MODE_PP &&
  15889. + !(cell->blind_full_slots & (1 << n)))
  15890. + continue;
  15891. +
  15892. + chd->carrier = e->carrier;
  15893. + chd->slot = dect_normal_transmit_base(cell->mode) + e->slot;
  15894. + if (quick && dect_channel_delay(cell, chd) > 3)
  15895. + continue;
  15896. +
  15897. + trx = dect_select_transceiver(cell, chd);
  15898. + if (trx == NULL)
  15899. + continue;
  15900. + if (sel != NULL) {
  15901. + if (trx->index < tsel->index)
  15902. + continue;
  15903. + if (sel->rssi < e->rssi)
  15904. + continue;
  15905. + }
  15906. +
  15907. + sel = e;
  15908. + tsel = trx;
  15909. +
  15910. + /* Stop searching if this is the best possible choice */
  15911. + if (tsel->index == hweight16(cell->trg.trxmask))
  15912. + break;
  15913. + }
  15914. + }
  15915. +
  15916. + if (sel == NULL) {
  15917. + /* Check the first band again without considering delay when
  15918. + * no quickly accessible channel is available within the first
  15919. + * three bands. */
  15920. + if (quick) {
  15921. + quick = false;
  15922. + goto retry;
  15923. + }
  15924. + return -ENOSPC;
  15925. + }
  15926. +
  15927. + list_del_init(&sel->list);
  15928. + chl->available--;
  15929. + if (chl->available < DECT_CHANNEL_LIST_LOW_WATERMARK)
  15930. + dect_chl_schedule_update(cell, chl->pkt);
  15931. +
  15932. + chd->carrier = sel->carrier;
  15933. + chd->slot = dect_normal_transmit_base(cell->mode) + sel->slot;
  15934. + chl_debug(cell, chl, "select channel: carrier %u slot %u RSSI %u\n",
  15935. + chd->carrier, chd->slot, sel->rssi);
  15936. +
  15937. + *rssi = sel->rssi;
  15938. + *trxp = tsel;
  15939. + return 0;
  15940. +}
  15941. +
  15942. +static struct dect_dbc *dect_dbc_get(const struct dect_cell *cell)
  15943. +{
  15944. + if (list_empty(&cell->dbcs))
  15945. + return NULL;
  15946. + return list_first_entry(&cell->dbcs, struct dect_dbc, list);
  15947. +}
  15948. +
  15949. +
  15950. +/*
  15951. + * Tail message parsing/construction
  15952. + */
  15953. +
  15954. +static enum dect_tail_identifications dect_parse_tail(const struct sk_buff *skb)
  15955. +{
  15956. + return skb->data[DECT_HDR_TA_OFF] & DECT_HDR_TA_MASK;
  15957. +}
  15958. +
  15959. +static enum dect_b_identifications dect_parse_b_id(const struct sk_buff *skb)
  15960. +{
  15961. + return skb->data[DECT_HDR_TA_OFF] & DECT_HDR_BA_MASK;
  15962. +}
  15963. +
  15964. +static int dect_parse_identities_information(struct dect_tail_msg *tm, u64 t)
  15965. +{
  15966. + struct dect_idi *idi = &tm->idi;
  15967. + u8 ari_len, rpn_len;
  15968. +
  15969. + ari_len = dect_parse_ari(&idi->pari, t << DECT_RFPI_ARI_SHIFT);
  15970. + if (ari_len == 0)
  15971. + return -1;
  15972. + rpn_len = BITS_PER_BYTE * DECT_NT_ID_RFPI_LEN - 1 - ari_len;
  15973. +
  15974. + idi->e = (t & DECT_RFPI_E_FLAG);
  15975. + idi->rpn = (t >> DECT_RFPI_RPN_SHIFT) & ((1 << rpn_len) - 1);
  15976. + tm->type = DECT_TM_TYPE_ID;
  15977. +
  15978. + pr_debug("identities information: e: %u class: %u emc: %.4x "
  15979. + "fpn: %.5x rpn: %x\n", idi->e, idi->pari.arc,
  15980. + idi->pari.emc, idi->pari.fpn, idi->rpn);
  15981. + return 0;
  15982. +}
  15983. +
  15984. +static u64 dect_build_identities_information(const struct dect_idi *idi)
  15985. +{
  15986. + return dect_build_rfpi(idi);
  15987. +}
  15988. +
  15989. +static int dect_parse_static_system_information(struct dect_tail_msg *tm, u64 t)
  15990. +{
  15991. + struct dect_ssi *ssi = &tm->ssi;
  15992. +
  15993. + ssi->nr = (t & DECT_QT_SSI_NR_FLAG);
  15994. + ssi->sn = (t & DECT_QT_SSI_SN_MASK) >> DECT_QT_SSI_SN_SHIFT;
  15995. + ssi->sp = (t & DECT_QT_SSI_SP_MASK) >> DECT_QT_SSI_SP_SHIFT;
  15996. + ssi->txs = (t & DECT_QT_SSI_TXS_MASK) >> DECT_QT_SSI_TXS_SHIFT;
  15997. + ssi->mc = (t & DECT_QT_SSI_MC_FLAG);
  15998. + ssi->rfcars = (t & DECT_QT_SSI_RFCARS_MASK) >> DECT_QT_SSI_RFCARS_SHIFT;
  15999. + ssi->cn = (t & DECT_QT_SSI_CN_MASK) >> DECT_QT_SSI_CN_SHIFT;
  16000. + ssi->pscn = (t & DECT_QT_SSI_PSCN_MASK) >> DECT_QT_SSI_PSCN_SHIFT;
  16001. +
  16002. + if (ssi->sn > 11 || ssi->cn > 9 || ssi->pscn > 9 || ssi->rfcars == 0)
  16003. + return -1;
  16004. + tm->type = DECT_TM_TYPE_SSI;
  16005. +
  16006. + pr_debug("static system information: nr: %u sn: %u cn: %u pscn: %u\n",
  16007. + ssi->nr, ssi->sn, ssi->cn, ssi->pscn);
  16008. + return 0;
  16009. +}
  16010. +
  16011. +static u64 dect_build_static_system_information(const struct dect_ssi *ssi)
  16012. +{
  16013. + u64 t = 0;
  16014. +
  16015. + t |= ssi->nr ? DECT_QT_SSI_NR_FLAG : 0;
  16016. + t |= (u64)ssi->sn << DECT_QT_SSI_SN_SHIFT;
  16017. + t |= (u64)ssi->sp << DECT_QT_SSI_SP_SHIFT;
  16018. + t |= (u64)ssi->txs << DECT_QT_SSI_TXS_SHIFT;
  16019. + t |= (u64)ssi->cn << DECT_QT_SSI_CN_SHIFT;
  16020. + t |= ssi->mc ? DECT_QT_SSI_MC_FLAG : 0;
  16021. + t |= (u64)ssi->rfcars << DECT_QT_SSI_RFCARS_SHIFT;
  16022. + t |= (u64)ssi->pscn << DECT_QT_SSI_PSCN_SHIFT;
  16023. + t |= DECT_QT_SI_SSI;
  16024. + return t;
  16025. +}
  16026. +
  16027. +static int dect_parse_extended_rf_carrier_information(struct dect_tail_msg *tm, u64 t)
  16028. +{
  16029. + struct dect_erfc *erfc = &tm->erfc;
  16030. +
  16031. + erfc->rfcars = (t & DECT_QT_ERFC_RFCARS_MASK) >>
  16032. + DECT_QT_ERFC_RFCARS_SHIFT;
  16033. + erfc->band = (t & DECT_QT_ERFC_RFBAND_MASK) >>
  16034. + DECT_QT_ERFC_RFBAND_SHIFT;
  16035. + erfc->num_rfcars = (t & DECT_QT_ERFC_NUM_RFCARS_MASK) >
  16036. + DECT_QT_ERFC_NUM_RFCARS_SHIFT;
  16037. + tm->type = DECT_TM_TYPE_ERFC;
  16038. +
  16039. + pr_debug("extended rf carrier information: rfcars %.6x band %u num %u\n",
  16040. + erfc->rfcars, erfc->band, erfc->num_rfcars);
  16041. + return 0;
  16042. +}
  16043. +
  16044. +static u64 dect_build_extended_rf_carrier_information(const struct dect_erfc *erfc)
  16045. +{
  16046. + u64 t = 0;
  16047. +
  16048. + t |= (u64)erfc->rfcars << DECT_QT_ERFC_RFCARS_SHIFT;
  16049. + t |= (u64)erfc->band << DECT_QT_ERFC_RFBAND_SHIFT;
  16050. + t |= (u64)erfc->num_rfcars << DECT_QT_ERFC_NUM_RFCARS_SHIFT;
  16051. + t |= DECT_QT_SI_ERFC;
  16052. + return t;
  16053. +}
  16054. +
  16055. +static int dect_parse_fixed_part_capabilities(struct dect_tail_msg *tm, u64 t)
  16056. +{
  16057. + struct dect_fpc *fpc = &tm->fpc;
  16058. +
  16059. + fpc->fpc = (t & DECT_QT_FPC_CAPABILITY_MASK) >>
  16060. + DECT_QT_FPC_CAPABILITY_SHIFT;
  16061. + fpc->hlc = (t & DECT_QT_FPC_HLC_MASK) >> DECT_QT_FPC_HLC_SHIFT;
  16062. + tm->type = DECT_TM_TYPE_FPC;
  16063. +
  16064. + pr_debug("fixed part capabilities: fpc: %.5x hlc: %.4x\n",
  16065. + fpc->fpc, fpc->hlc);
  16066. + return 0;
  16067. +}
  16068. +
  16069. +static u64 dect_build_fixed_part_capabilities(const struct dect_fpc *fpc)
  16070. +{
  16071. + u64 t = 0;
  16072. +
  16073. + t |= (u64)fpc->fpc << DECT_QT_FPC_CAPABILITY_SHIFT;
  16074. + t |= (u64)fpc->hlc << DECT_QT_FPC_HLC_SHIFT;
  16075. + t |= DECT_QT_SI_FPC;
  16076. + return t;
  16077. +}
  16078. +
  16079. +static int dect_parse_extended_fixed_part_capabilities(struct dect_tail_msg *tm, u64 t)
  16080. +{
  16081. + struct dect_efpc *efpc = &tm->efpc;
  16082. +
  16083. + efpc->fpc = (t & DECT_QT_EFPC_EFPC_MASK) >> DECT_QT_EFPC_EFPC_SHIFT;
  16084. + efpc->hlc = (t & DECT_QT_EFPC_EHLC_MASK) >> DECT_QT_EFPC_EHLC_SHIFT;
  16085. + tm->type = DECT_TM_TYPE_EFPC;
  16086. +
  16087. + pr_debug("extended fixed part capabilities: fpc: %.5x hlc: %.6x\n",
  16088. + efpc->fpc, efpc->hlc);
  16089. + return 0;
  16090. +}
  16091. +
  16092. +static u64 dect_build_extended_fixed_part_capabilities(const struct dect_efpc *efpc)
  16093. +{
  16094. + u64 t = 0;
  16095. +
  16096. + t |= (u64)efpc->fpc << DECT_QT_EFPC_EFPC_SHIFT;
  16097. + t |= (u64)efpc->hlc << DECT_QT_EFPC_EHLC_SHIFT;
  16098. + t |= DECT_QT_SI_EFPC;
  16099. + return t;
  16100. +}
  16101. +
  16102. +static int dect_parse_extended_fixed_part_capabilities2(struct dect_tail_msg *tm, u64 t)
  16103. +{
  16104. + struct dect_efpc2 *efpc2 = &tm->efpc2;
  16105. +
  16106. + efpc2->fpc = (t & DECT_QT_EFPC2_FPC_MASK) >> DECT_QT_EFPC2_FPC_SHIFT;
  16107. + efpc2->hlc = (t & DECT_QT_EFPC2_HLC_MASK) >> DECT_QT_EFPC2_HLC_SHIFT;
  16108. + tm->type = DECT_TM_TYPE_EFPC2;
  16109. +
  16110. + pr_debug("extended fixed part capabilities2: fpc: %x hlc: %x\n",
  16111. + efpc2->fpc, efpc2->hlc);
  16112. + return 0;
  16113. +}
  16114. +
  16115. +static u64 dect_build_extended_fixed_part_capabilities2(const struct dect_efpc2 *efpc2)
  16116. +{
  16117. + u64 t = 0;
  16118. +
  16119. + t |= (u64)efpc2->fpc << DECT_QT_EFPC2_FPC_SHIFT;
  16120. + t |= (u64)efpc2->hlc << DECT_QT_EFPC2_HLC_SHIFT;
  16121. + t |= DECT_QT_SI_EFPC2;
  16122. + return t;
  16123. +}
  16124. +
  16125. +static int dect_parse_sari(struct dect_tail_msg *tm, u64 t)
  16126. +{
  16127. + struct dect_sari *sari = &tm->sari;
  16128. +
  16129. + sari->list_cycle = (((t & DECT_QT_SARI_LIST_CYCLE_MASK) >>
  16130. + DECT_QT_SARI_LIST_CYCLE_SHIFT) + 1) * 2;
  16131. + sari->tari = (t & DECT_QT_SARI_TARI_FLAG);
  16132. + sari->black = (t & DECT_QT_SARI_BLACK_FLAG);
  16133. + dect_parse_ari(&sari->ari, t << DECT_QT_SARI_ARI_SHIFT);
  16134. + tm->type = DECT_TM_TYPE_SARI;
  16135. +
  16136. + pr_debug("sari: cycle %u tari: %u black: %u\n",
  16137. + sari->list_cycle, sari->tari, sari->black);
  16138. + return 0;
  16139. +}
  16140. +
  16141. +static u64 dect_build_sari(const struct dect_sari *sari)
  16142. +{
  16143. + u64 t = 0;
  16144. +
  16145. + t |= sari->tari ? DECT_QT_SARI_TARI_FLAG : 0;
  16146. + t |= sari->black ? DECT_QT_SARI_BLACK_FLAG : 0;
  16147. + t |= dect_build_ari(&sari->ari) >> DECT_QT_SARI_ARI_SHIFT;
  16148. + t |= DECT_QT_SI_SARI;
  16149. + return t;
  16150. +}
  16151. +
  16152. +static int dect_parse_multiframe_number(struct dect_tail_msg *tm, u64 t)
  16153. +{
  16154. + tm->mfn.num = (t & DECT_QT_MFN_MASK) >> DECT_QT_MFN_SHIFT;
  16155. + tm->type = DECT_TM_TYPE_MFN;
  16156. +
  16157. + pr_debug("multi-frame number: %u\n", tm->mfn.num);
  16158. + return 0;
  16159. +}
  16160. +
  16161. +static u64 dect_build_multiframe_number(const struct dect_mfn *mfn)
  16162. +{
  16163. + u64 t = 0;
  16164. +
  16165. + t |= (u64)mfn->num << DECT_QT_MFN_SHIFT;
  16166. + t |= DECT_QT_SI_MFN;
  16167. + return t;
  16168. +}
  16169. +
  16170. +static int dect_parse_system_information(struct dect_tail_msg *tm, u64 t)
  16171. +{
  16172. + /* clear of memcmp */
  16173. + memset(((void *)tm) + offsetof(struct dect_tail_msg, ssi), 0,
  16174. + sizeof(*tm) - offsetof(struct dect_tail_msg, ssi));
  16175. +
  16176. + switch (t & DECT_QT_H_MASK) {
  16177. + case DECT_QT_SI_SSI:
  16178. + case DECT_QT_SI_SSI2:
  16179. + return dect_parse_static_system_information(tm, t);
  16180. + case DECT_QT_SI_ERFC:
  16181. + return dect_parse_extended_rf_carrier_information(tm, t);
  16182. + case DECT_QT_SI_FPC:
  16183. + return dect_parse_fixed_part_capabilities(tm, t);
  16184. + case DECT_QT_SI_EFPC:
  16185. + return dect_parse_extended_fixed_part_capabilities(tm, t);
  16186. + case DECT_QT_SI_EFPC2:
  16187. + return dect_parse_extended_fixed_part_capabilities2(tm, t);
  16188. + case DECT_QT_SI_SARI:
  16189. + return dect_parse_sari(tm, t);
  16190. + case DECT_QT_SI_MFN:
  16191. + return dect_parse_multiframe_number(tm, t);
  16192. + default:
  16193. + pr_debug("unknown system information type %llx\n",
  16194. + (unsigned long long)t & DECT_QT_H_MASK);
  16195. + return -1;
  16196. + }
  16197. +}
  16198. +
  16199. +static int dect_parse_blind_full_slots(struct dect_tail_msg *tm, u64 t)
  16200. +{
  16201. + struct dect_bfs *bfs = &tm->bfs;
  16202. +
  16203. + bfs->mask = (t & DECT_PT_BFS_MASK) >> DECT_PT_BFS_SHIFT;
  16204. + tm->type = DECT_TM_TYPE_BFS;
  16205. +
  16206. + pr_debug("page: RFPI: %.3x blind full slots: %.3x\n",
  16207. + tm->page.rfpi, bfs->mask);
  16208. + return 0;
  16209. +}
  16210. +
  16211. +static u64 dect_build_blind_full_slots(const struct dect_bfs *bfs)
  16212. +{
  16213. + u64 t = 0;
  16214. +
  16215. + t |= (u64)bfs->mask << DECT_PT_BFS_SHIFT;
  16216. + t |= DECT_PT_IT_BLIND_FULL_SLOT;
  16217. + return t;
  16218. +}
  16219. +
  16220. +static int dect_parse_bearer_description(struct dect_tail_msg *tm, u64 t)
  16221. +{
  16222. + struct dect_bearer_desc *bd = &tm->bd;
  16223. +
  16224. + bd->bt = (t & DECT_PT_INFO_TYPE_MASK);
  16225. + bd->sn = (t & DECT_PT_BEARER_SN_MASK) >> DECT_PT_BEARER_SN_SHIFT;
  16226. + bd->sp = (t & DECT_PT_BEARER_SP_MASK) >> DECT_PT_BEARER_SP_SHIFT;
  16227. + bd->cn = (t & DECT_PT_BEARER_CN_MASK) >> DECT_PT_BEARER_CN_SHIFT;
  16228. + if (bd->sn >= DECT_HALF_FRAME_SIZE)
  16229. + return -1;
  16230. + tm->type = DECT_TM_TYPE_BD;
  16231. +
  16232. + pr_debug("page: RFPI: %.3x bearer description: bt: %llx sn: %u sp: %u cn: %u\n",
  16233. + tm->page.rfpi, (unsigned long long)bd->bt, bd->sn, bd->sp, bd->cn);
  16234. + return 0;
  16235. +}
  16236. +
  16237. +static u64 dect_build_bearer_description(const struct dect_bearer_desc *bd)
  16238. +{
  16239. + u64 t = 0;
  16240. +
  16241. + t |= (u64)bd->sn << DECT_PT_BEARER_SN_SHIFT;
  16242. + t |= (u64)bd->sp << DECT_PT_BEARER_SP_SHIFT;
  16243. + t |= (u64)bd->cn << DECT_PT_BEARER_CN_SHIFT;
  16244. + t |= bd->bt;
  16245. + return t;
  16246. +}
  16247. +
  16248. +static int dect_parse_rfp_identity(struct dect_tail_msg *tm, u64 t)
  16249. +{
  16250. + struct dect_rfp_id *id = &tm->rfp_id;
  16251. +
  16252. + id->id = (t & DECT_PT_RFP_ID_MASK) >> DECT_PT_RFP_ID_SHIFT;
  16253. + tm->type = DECT_TM_TYPE_RFP_ID;
  16254. +
  16255. + pr_debug("page: RFPI: %.3x RFP identity: %.3x\n",
  16256. + tm->page.rfpi, id->id);
  16257. + return 0;
  16258. +}
  16259. +
  16260. +static u64 dect_build_rfp_identity(const struct dect_rfp_id *id)
  16261. +{
  16262. + u64 t = 0;
  16263. +
  16264. + t |= (u64)id->id << DECT_PT_RFP_ID_SHIFT;
  16265. + t |= DECT_PT_IT_RFP_IDENTITY;
  16266. + return t;
  16267. +}
  16268. +
  16269. +static int dect_parse_rfp_status(struct dect_tail_msg *tm, u64 t)
  16270. +{
  16271. + struct dect_rfp_status *st = &tm->rfp_status;
  16272. +
  16273. + st->rfp_busy = t & DECT_PT_RFPS_RFP_BUSY_FLAG;
  16274. + st->sys_busy = t & DECT_PT_RFPS_SYS_BUSY_FLAG;
  16275. + tm->type = DECT_TM_TYPE_RFP_STATUS;
  16276. +
  16277. + pr_debug("page: RFPI: %.3x RFP status: rfp_busy: %d sys_busy: %d\n",
  16278. + tm->page.rfpi, st->rfp_busy, st->sys_busy);
  16279. + return 0;
  16280. +}
  16281. +
  16282. +static u64 dect_build_rfp_status(const struct dect_rfp_status *st)
  16283. +{
  16284. + u64 t = 0;
  16285. +
  16286. + t |= st->rfp_busy ? DECT_PT_RFPS_RFP_BUSY_FLAG : 0;
  16287. + t |= st->sys_busy ? DECT_PT_RFPS_SYS_BUSY_FLAG : 0;
  16288. + t |= DECT_PT_IT_RFP_STATUS;
  16289. + return t;
  16290. +}
  16291. +
  16292. +static int dect_parse_active_carriers(struct dect_tail_msg *tm, u64 t)
  16293. +{
  16294. + struct dect_active_carriers *ac = &tm->active_carriers;
  16295. +
  16296. + ac->active = (t & DECT_PT_ACTIVE_CARRIERS_MASK) >>
  16297. + DECT_PT_ACTIVE_CARRIERS_SHIFT;
  16298. + tm->type = DECT_TM_TYPE_ACTIVE_CARRIERS;
  16299. +
  16300. + pr_debug("page: RFPI: %.3x active carriers: %.3x\n",
  16301. + tm->page.rfpi, ac->active);
  16302. + return 0;
  16303. +}
  16304. +
  16305. +static u64 dect_build_active_carriers(const struct dect_active_carriers *ac)
  16306. +{
  16307. + u64 t = 0;
  16308. +
  16309. + t |= (u64)ac->active << DECT_PT_ACTIVE_CARRIERS_SHIFT;
  16310. + t |= DECT_PT_IT_ACTIVE_CARRIERS;
  16311. + return t;
  16312. +}
  16313. +
  16314. +static int dect_parse_paging_info(struct dect_tail_msg *tm, u64 t)
  16315. +{
  16316. + switch (t & DECT_PT_INFO_TYPE_MASK) {
  16317. + case DECT_PT_IT_BLIND_FULL_SLOT:
  16318. + return dect_parse_blind_full_slots(tm, t);
  16319. + case DECT_PT_IT_OTHER_BEARER:
  16320. + case DECT_PT_IT_RECOMMENDED_OTHER_BEARER:
  16321. + case DECT_PT_IT_GOOD_RFP_BEARER:
  16322. + case DECT_PT_IT_DUMMY_OR_CL_BEARER_POSITION:
  16323. + case DECT_PT_IT_CL_BEARER_POSITION:
  16324. + return dect_parse_bearer_description(tm, t);
  16325. + case DECT_PT_IT_RFP_IDENTITY:
  16326. + return dect_parse_rfp_identity(tm, t);
  16327. + case DECT_PT_IT_DUMMY_OR_CL_BEARER_MARKER:
  16328. + pr_debug("dummy or cl bearer marker\n");
  16329. + return 0;
  16330. + case DECT_PT_IT_RFP_STATUS:
  16331. + return dect_parse_rfp_status(tm, t);
  16332. + case DECT_PT_IT_ACTIVE_CARRIERS:
  16333. + return dect_parse_active_carriers(tm, t);
  16334. + default:
  16335. + pr_debug("unknown MAC page info %llx\n",
  16336. + (unsigned long long)t & DECT_PT_INFO_TYPE_MASK);
  16337. + return -1;
  16338. + }
  16339. +}
  16340. +
  16341. +static int dect_parse_paging_msg(struct dect_tail_msg *tm, u64 t)
  16342. +{
  16343. + tm->page.extend = t & DECT_PT_HDR_EXTEND_FLAG;
  16344. + tm->page.length = t & DECT_PT_HDR_LENGTH_MASK;
  16345. +
  16346. + switch (tm->page.length) {
  16347. + case DECT_PT_ZERO_PAGE:
  16348. + tm->page.rfpi = (t & DECT_PT_ZP_RFPI_MASK) >>
  16349. + DECT_PT_ZP_RFPI_SHIFT;
  16350. +
  16351. + return dect_parse_paging_info(tm, t);
  16352. + case DECT_PT_SHORT_PAGE:
  16353. + tm->page.rfpi = 0;
  16354. + return dect_parse_paging_info(tm, t);
  16355. + case DECT_PT_FULL_PAGE:
  16356. + case DECT_PT_LONG_PAGE:
  16357. + case DECT_PT_LONG_PAGE_FIRST:
  16358. + case DECT_PT_LONG_PAGE_LAST:
  16359. + case DECT_PT_LONG_PAGE_ALL:
  16360. + tm->type = DECT_TM_TYPE_PAGE;
  16361. + pr_debug("full/long page: extend: %u length: %llx\n",
  16362. + tm->page.extend, (unsigned long long)tm->page.length);
  16363. + return 0;
  16364. + default:
  16365. + pr_debug("invalid page length %llx\n",
  16366. + (unsigned long long)tm->page.length);
  16367. + return -1;
  16368. + }
  16369. +}
  16370. +
  16371. +static int dect_parse_cctrl_common(struct dect_cctrl *cctl, u64 t)
  16372. +{
  16373. + cctl->fmid = (t & DECT_CCTRL_FMID_MASK) >> DECT_CCTRL_FMID_SHIFT;
  16374. + cctl->pmid = (t & DECT_CCTRL_PMID_MASK) >> DECT_CCTRL_PMID_SHIFT;
  16375. +
  16376. + pr_debug("cctrl: cmd: %llx fmid: %.3x pmid: %.5x\n",
  16377. + (unsigned long long)cctl->cmd, cctl->fmid, cctl->pmid);
  16378. + return 0;
  16379. +}
  16380. +
  16381. +static u64 dect_build_cctrl_common(const struct dect_cctrl *cctl)
  16382. +{
  16383. + u64 t = 0;
  16384. +
  16385. + t |= cctl->cmd;
  16386. + t |= (u64)cctl->fmid << DECT_CCTRL_FMID_SHIFT;
  16387. + t |= (u64)cctl->pmid << DECT_CCTRL_PMID_SHIFT;
  16388. + return t;
  16389. +}
  16390. +
  16391. +static int dect_parse_cctrl_attr(struct dect_cctrl *cctl, u64 t)
  16392. +{
  16393. + cctl->attr.ecn = (t & DECT_CCTRL_ATTR_ECN_MASK) >> DECT_CCTRL_ATTR_ECN_SHIFT;
  16394. + cctl->attr.lbn = (t & DECT_CCTRL_ATTR_LBN_MASK) >> DECT_CCTRL_ATTR_LBN_SHIFT;
  16395. + cctl->attr.type = (t & DECT_CCTRL_ATTR_TYPE_MASK) >> DECT_CCTRL_ATTR_TYPE_SHIFT;
  16396. + cctl->attr.service = (t & DECT_CCTRL_ATTR_SERVICE_MASK) >> DECT_CCTRL_ATTR_SERVICE_SHIFT;
  16397. + cctl->attr.slot = (t & DECT_CCTRL_ATTR_SLOT_MASK) >> DECT_CCTRL_ATTR_SLOT_SHIFT;
  16398. + cctl->attr.cf = (t & DECT_CCTRL_ATTR_CF_FLAG);
  16399. + cctl->attr.a_mod = (t & DECT_CCTRL_ATTR_A_MOD_MASK) >> DECT_CCTRL_ATTR_A_MOD_SHIFT;
  16400. + cctl->attr.bz_mod = (t & DECT_CCTRL_ATTR_BZ_MOD_MASK) >> DECT_CCTRL_ATTR_BZ_MOD_SHIFT;
  16401. + cctl->attr.bz_ext_mod = (t & DECT_CCTRL_ATTR_BZ_EXT_MOD_MASK) >> DECT_CCTRL_ATTR_BZ_EXT_MOD_SHIFT;
  16402. + cctl->attr.acr = (t & DECT_CCTRL_ATTR_ACR_MASK) >> DECT_CCTRL_ATTR_ACR_SHIFT;
  16403. +
  16404. + pr_debug("cctrl: cmd: %llx ecn: %x lbn: %x type: %x "
  16405. + "service: %x slot: %x cf %d a_mod %x bz_mod %x bz_ext_mod %x acr %x\n",
  16406. + (unsigned long long)cctl->cmd, cctl->attr.ecn, cctl->attr.lbn,
  16407. + cctl->attr.type, cctl->attr.service, cctl->attr.slot,
  16408. + cctl->attr.cf, cctl->attr.a_mod, cctl->attr.bz_mod,
  16409. + cctl->attr.bz_ext_mod, cctl->attr.acr);
  16410. + return 0;
  16411. +}
  16412. +
  16413. +static u64 dect_build_cctrl_attr(const struct dect_cctrl *cctl)
  16414. +{
  16415. + u64 t = 0;
  16416. +
  16417. + t |= cctl->cmd;
  16418. + t |= (u64)cctl->attr.ecn << DECT_CCTRL_ATTR_ECN_SHIFT;
  16419. + t |= (u64)cctl->attr.lbn << DECT_CCTRL_ATTR_LBN_SHIFT;
  16420. + t |= (u64)cctl->attr.type << DECT_CCTRL_ATTR_TYPE_SHIFT;
  16421. + t |= (u64)cctl->attr.service << DECT_CCTRL_ATTR_SERVICE_SHIFT;
  16422. + t |= (u64)cctl->attr.slot << DECT_CCTRL_ATTR_SLOT_SHIFT;
  16423. + t |= cctl->attr.cf ? DECT_CCTRL_ATTR_CF_FLAG : 0;
  16424. + t |= (u64)cctl->attr.a_mod << DECT_CCTRL_ATTR_A_MOD_SHIFT;
  16425. + t |= (u64)cctl->attr.bz_mod << DECT_CCTRL_ATTR_BZ_MOD_SHIFT;
  16426. + t |= (u64)cctl->attr.bz_ext_mod << DECT_CCTRL_ATTR_BZ_EXT_MOD_SHIFT;
  16427. + t |= (u64)cctl->attr.acr << DECT_CCTRL_ATTR_ACR_SHIFT;
  16428. + return t;
  16429. +}
  16430. +
  16431. +static int dect_parse_cctrl_release(struct dect_cctrl *cctl, u64 t)
  16432. +{
  16433. + cctl->rel.lbn = (t & DECT_CCTRL_RELEASE_LBN_MASK) >>
  16434. + DECT_CCTRL_RELEASE_LBN_SHIFT;
  16435. + cctl->rel.reason = (t & DECT_CCTRL_RELEASE_REASON_MASK) >>
  16436. + DECT_CCTRL_RELEASE_REASON_SHIFT;
  16437. + cctl->pmid = (t & DECT_CCTRL_RELEASE_PMID_MASK) >>
  16438. + DECT_CCTRL_RELEASE_PMID_SHIFT;
  16439. +
  16440. + pr_debug("cctrl: release: pmid: %.5x lbn: %x reason: %x\n",
  16441. + cctl->pmid, cctl->rel.lbn, cctl->rel.reason);
  16442. + return 0;
  16443. +}
  16444. +
  16445. +static u64 dect_build_cctrl_release(const struct dect_cctrl *cctl)
  16446. +{
  16447. + u64 t = 0;
  16448. +
  16449. + t |= cctl->cmd;
  16450. + t |= (u64)cctl->rel.lbn << DECT_CCTRL_RELEASE_LBN_SHIFT;
  16451. + t |= (u64)cctl->rel.reason << DECT_CCTRL_RELEASE_REASON_SHIFT;
  16452. + t |= (u64)cctl->pmid << DECT_CCTRL_RELEASE_PMID_SHIFT;
  16453. + return t;
  16454. +}
  16455. +
  16456. +static int dect_parse_basic_cctrl(struct dect_tail_msg *tm, u64 t)
  16457. +{
  16458. + struct dect_cctrl *cctl = &tm->cctl;
  16459. +
  16460. + cctl->cmd = t & DECT_MT_CMD_MASK;
  16461. + switch (cctl->cmd) {
  16462. + case DECT_CCTRL_ACCESS_REQ:
  16463. + case DECT_CCTRL_BEARER_HANDOVER_REQ:
  16464. + case DECT_CCTRL_CONNECTION_HANDOVER_REQ:
  16465. + case DECT_CCTRL_UNCONFIRMED_ACCESS_REQ:
  16466. + case DECT_CCTRL_BEARER_CONFIRM:
  16467. + case DECT_CCTRL_WAIT:
  16468. + return dect_parse_cctrl_common(cctl, t);
  16469. + case DECT_CCTRL_ATTRIBUTES_T_REQUEST:
  16470. + case DECT_CCTRL_ATTRIBUTES_T_CONFIRM:
  16471. + return dect_parse_cctrl_attr(cctl, t);
  16472. + case DECT_CCTRL_RELEASE:
  16473. + return dect_parse_cctrl_release(cctl, t);
  16474. + default:
  16475. + pr_debug("unknown cctrl command: %llx\n",
  16476. + (unsigned long long)cctl->cmd);
  16477. + return -1;
  16478. + }
  16479. +}
  16480. +
  16481. +static int dect_parse_advanced_cctrl(struct dect_tail_msg *tm, u64 t)
  16482. +{
  16483. + struct dect_cctrl *cctl = &tm->cctl;
  16484. +
  16485. + cctl->cmd = t & DECT_MT_CMD_MASK;
  16486. + switch (cctl->cmd) {
  16487. + case DECT_CCTRL_UNCONFIRMED_DUMMY:
  16488. + case DECT_CCTRL_UNCONFIRMED_HANDOVER:
  16489. + return dect_parse_cctrl_common(cctl, t);
  16490. + case DECT_CCTRL_BANDWIDTH_T_REQUEST:
  16491. + case DECT_CCTRL_BANDWIDTH_T_CONFIRM:
  16492. + return -1;
  16493. + default:
  16494. + return dect_parse_basic_cctrl(tm, t);
  16495. + }
  16496. +}
  16497. +
  16498. +static int dect_parse_encryption_ctrl(struct dect_tail_msg *tm, u64 t)
  16499. +{
  16500. + struct dect_encctrl *ectl = &tm->encctl;
  16501. +
  16502. + ectl->cmd = (t & DECT_ENCCTRL_CMD_MASK) >> DECT_ENCCTRL_CMD_SHIFT;
  16503. + ectl->fmid = (t & DECT_ENCCTRL_FMID_MASK) >> DECT_ENCCTRL_FMID_SHIFT;
  16504. + ectl->pmid = (t & DECT_ENCCTRL_PMID_MASK) >> DECT_ENCCTRL_PMID_SHIFT;
  16505. + pr_debug("encctrl: cmd: %x fmid: %.4x pmid: %.5x\n",
  16506. + ectl->cmd, ectl->fmid, ectl->pmid);
  16507. + return 0;
  16508. +}
  16509. +
  16510. +static u64 dect_build_encryption_ctrl(const struct dect_encctrl *ectl)
  16511. +{
  16512. + u64 t = 0;
  16513. +
  16514. + t |= (u64)DECT_ENCCTRL_FILL_MASK;
  16515. + t |= (u64)ectl->cmd << DECT_ENCCTRL_CMD_SHIFT;
  16516. + t |= (u64)ectl->fmid << DECT_ENCCTRL_FMID_SHIFT;
  16517. + t |= (u64)ectl->pmid << DECT_ENCCTRL_PMID_SHIFT;
  16518. + return t;
  16519. +}
  16520. +
  16521. +static int dect_parse_mac_ctrl(struct dect_tail_msg *tm, u64 t)
  16522. +{
  16523. + switch (t & DECT_MT_HDR_MASK) {
  16524. + case DECT_MT_BASIC_CCTRL:
  16525. + if (dect_parse_basic_cctrl(tm, t) < 0)
  16526. + return -1;
  16527. + tm->type = DECT_TM_TYPE_BCCTRL;
  16528. + return 0;
  16529. + case DECT_MT_ADV_CCTRL:
  16530. + if (dect_parse_advanced_cctrl(tm, t) < 0)
  16531. + return -1;
  16532. + tm->type = DECT_TM_TYPE_ACCTRL;
  16533. + return 0;
  16534. + case DECT_MT_ENC_CTRL:
  16535. + if (dect_parse_encryption_ctrl(tm, t) < 0)
  16536. + return -1;
  16537. + tm->type = DECT_TM_TYPE_ENCCTRL;
  16538. + return 0;
  16539. + default:
  16540. + pr_debug("Unknown MAC control %llx\n",
  16541. + (unsigned long long)t & DECT_MT_HDR_MASK);
  16542. + return -1;
  16543. + }
  16544. +}
  16545. +
  16546. +static u64 dect_build_cctrl(const struct dect_cctrl *cctl)
  16547. +{
  16548. + switch (cctl->cmd) {
  16549. + case DECT_CCTRL_ACCESS_REQ:
  16550. + case DECT_CCTRL_BEARER_HANDOVER_REQ:
  16551. + case DECT_CCTRL_CONNECTION_HANDOVER_REQ:
  16552. + case DECT_CCTRL_UNCONFIRMED_ACCESS_REQ:
  16553. + case DECT_CCTRL_BEARER_CONFIRM:
  16554. + case DECT_CCTRL_WAIT:
  16555. + case DECT_CCTRL_UNCONFIRMED_DUMMY:
  16556. + case DECT_CCTRL_UNCONFIRMED_HANDOVER:
  16557. + return dect_build_cctrl_common(cctl);
  16558. + case DECT_CCTRL_ATTRIBUTES_T_REQUEST:
  16559. + case DECT_CCTRL_ATTRIBUTES_T_CONFIRM:
  16560. + return dect_build_cctrl_attr(cctl);
  16561. + case DECT_CCTRL_BANDWIDTH_T_REQUEST:
  16562. + case DECT_CCTRL_BANDWIDTH_T_CONFIRM:
  16563. + case DECT_CCTRL_CHANNEL_LIST:
  16564. + return 0;
  16565. + case DECT_CCTRL_RELEASE:
  16566. + return dect_build_cctrl_release(cctl);
  16567. + default:
  16568. + return 0;
  16569. + }
  16570. +}
  16571. +
  16572. +static int dect_parse_ct_data(struct dect_tail_msg *tm, u64 t, u8 seq)
  16573. +{
  16574. + struct dect_ct_data *ctd = &tm->ctd;
  16575. +
  16576. + ctd->seq = seq;
  16577. + tm->type = DECT_TM_TYPE_CT;
  16578. + pr_debug("C_S tail sequence number %u\n", seq);
  16579. + return 0;
  16580. +}
  16581. +
  16582. +static int dect_parse_tail_msg(struct dect_tail_msg *tm,
  16583. + const struct sk_buff *skb)
  16584. +{
  16585. + u64 t;
  16586. +
  16587. + tm->type = DECT_TM_TYPE_INVALID;
  16588. + WARN_ON_ONCE(!IS_ALIGNED((unsigned long)skb->data, __alignof__(u64)));
  16589. + t = be64_to_cpu(*(__be64 *)skb->data);
  16590. +
  16591. + switch (dect_parse_tail(skb)) {
  16592. + case DECT_TI_CT_PKT_0:
  16593. + return dect_parse_ct_data(tm, t, 0);
  16594. + case DECT_TI_CT_PKT_1:
  16595. + return dect_parse_ct_data(tm, t, 1);
  16596. + case DECT_TI_NT_CL:
  16597. + pr_debug("connectionless: ");
  16598. + case DECT_TI_NT:
  16599. + return dect_parse_identities_information(tm, t);
  16600. + case DECT_TI_QT:
  16601. + return dect_parse_system_information(tm, t);
  16602. + case DECT_TI_PT:
  16603. + /* Paging tail in direction FP->PP, MAC control otherwise */
  16604. + if (DECT_TRX_CB(skb)->slot < 12)
  16605. + return dect_parse_paging_msg(tm, t);
  16606. + case DECT_TI_MT:
  16607. + return dect_parse_mac_ctrl(tm, t);
  16608. + default:
  16609. + pr_debug("unknown tail %x\n", dect_parse_tail(skb));
  16610. + return -1;
  16611. + }
  16612. +}
  16613. +
  16614. +static struct sk_buff *dect_build_tail_msg(struct sk_buff *skb,
  16615. + enum dect_tail_msg_types type,
  16616. + const void *data)
  16617. +{
  16618. + enum dect_tail_identifications ti;
  16619. + unsigned int i;
  16620. + u64 t;
  16621. +
  16622. + switch (type) {
  16623. + case DECT_TM_TYPE_ID:
  16624. + t = dect_build_identities_information(data);
  16625. + ti = DECT_TI_NT;
  16626. + break;
  16627. + case DECT_TM_TYPE_SSI:
  16628. + t = dect_build_static_system_information(data);
  16629. + ti = DECT_TI_QT;
  16630. + break;
  16631. + case DECT_TM_TYPE_ERFC:
  16632. + t = dect_build_extended_rf_carrier_information(data);
  16633. + ti = DECT_TI_QT;
  16634. + break;
  16635. + case DECT_TM_TYPE_FPC:
  16636. + t = dect_build_fixed_part_capabilities(data);
  16637. + ti = DECT_TI_QT;
  16638. + break;
  16639. + case DECT_TM_TYPE_EFPC:
  16640. + t = dect_build_extended_fixed_part_capabilities(data);
  16641. + ti = DECT_TI_QT;
  16642. + break;
  16643. + case DECT_TM_TYPE_EFPC2:
  16644. + t = dect_build_extended_fixed_part_capabilities2(data);
  16645. + ti = DECT_TI_QT;
  16646. + break;
  16647. + case DECT_TM_TYPE_SARI:
  16648. + t = dect_build_sari(data);
  16649. + ti = DECT_TI_QT;
  16650. + break;
  16651. + case DECT_TM_TYPE_MFN:
  16652. + t = dect_build_multiframe_number(data);
  16653. + ti = DECT_TI_QT;
  16654. + break;
  16655. + case DECT_TM_TYPE_BCCTRL:
  16656. + t = dect_build_cctrl(data) | DECT_MT_BASIC_CCTRL;
  16657. + ti = DECT_TI_MT;
  16658. + break;
  16659. + case DECT_TM_TYPE_ACCTRL:
  16660. + t = dect_build_cctrl(data) | DECT_MT_ADV_CCTRL;
  16661. + ti = DECT_TI_MT;
  16662. + break;
  16663. + case DECT_TM_TYPE_ENCCTRL:
  16664. + t = dect_build_encryption_ctrl(data);
  16665. + ti = DECT_TI_MT;
  16666. + break;
  16667. + default:
  16668. + BUG();
  16669. + }
  16670. +
  16671. + skb_put(skb, DECT_T_FIELD_SIZE);
  16672. + for (i = 0; i < DECT_T_FIELD_SIZE; i++)
  16673. + skb->data[i] = t >> ((sizeof(t) - i - 2) * BITS_PER_BYTE);
  16674. +
  16675. + DECT_A_CB(skb)->id = ti;
  16676. + return skb;
  16677. +}
  16678. +
  16679. +/**
  16680. + * dect_t_skb_alloc - allocate a socket buffer for the T-Field
  16681. + *
  16682. + */
  16683. +static struct sk_buff *dect_t_skb_alloc(void)
  16684. +{
  16685. + struct sk_buff *skb;
  16686. +
  16687. + skb = alloc_skb(DECT_PREAMBLE_SIZE + DECT_A_FIELD_SIZE, GFP_ATOMIC);
  16688. + if (skb == NULL)
  16689. + return NULL;
  16690. +
  16691. + /* Reserve space for preamble */
  16692. + skb_reset_mac_header(skb);
  16693. + skb_reserve(skb, DECT_PREAMBLE_SIZE);
  16694. +
  16695. + skb_reset_network_header(skb);
  16696. +
  16697. + /* Reserve space for Header Field */
  16698. + skb_reserve(skb, DECT_HDR_FIELD_SIZE);
  16699. + return skb;
  16700. +}
  16701. +
  16702. +/*
  16703. + * MAC Bearers
  16704. + */
  16705. +
  16706. +static void dect_bearer_enable(struct dect_bearer *bearer)
  16707. +{
  16708. + switch (bearer->mode) {
  16709. + case DECT_BEARER_RX:
  16710. + dect_set_channel_mode(bearer->trx, &bearer->chd, DECT_SLOT_RX);
  16711. + break;
  16712. + case DECT_BEARER_TX:
  16713. + dect_set_channel_mode(bearer->trx, &bearer->chd, DECT_SLOT_TX);
  16714. + break;
  16715. + };
  16716. + dect_set_carrier(bearer->trx, bearer->chd.slot, bearer->chd.carrier);
  16717. + bearer->state = DECT_BEARER_ENABLED;
  16718. +}
  16719. +
  16720. +static void dect_bearer_disable(struct dect_bearer *bearer)
  16721. +{
  16722. + dect_set_channel_mode(bearer->trx, &bearer->chd, DECT_SLOT_IDLE);
  16723. + bearer->trx->slots[bearer->chd.slot].bearer = NULL;
  16724. +}
  16725. +
  16726. +static void dect_bearer_timer_add(struct dect_cell *cell,
  16727. + struct dect_bearer *bearer,
  16728. + struct dect_timer *timer,
  16729. + unsigned int frames)
  16730. +{
  16731. + u8 slot = bearer->chd.slot;
  16732. +
  16733. + switch (bearer->mode) {
  16734. + case DECT_BEARER_RX:
  16735. + dect_timer_add(cell, timer, DECT_TIMER_RX, frames, slot);
  16736. + break;
  16737. + case DECT_BEARER_TX:
  16738. + dect_timer_add(cell, timer, DECT_TIMER_TX, frames, slot);
  16739. + break;
  16740. + }
  16741. +}
  16742. +
  16743. +/**
  16744. + * dect_bearer_release - release a MAC bearer
  16745. + *
  16746. + * Release a MAC bearer that is no longer used. The unused slot position is
  16747. + * given to IRC and converted to a scan bearer.
  16748. + */
  16749. +static void dect_scan_bearer_enable(struct dect_transceiver *trx,
  16750. + const struct dect_channel_desc *chd);
  16751. +
  16752. +static void dect_bearer_release(struct dect_cell *cell,
  16753. + struct dect_bearer *bearer)
  16754. +{
  16755. + struct dect_transceiver *trx = bearer->trx;
  16756. + u8 slot = bearer->chd.slot;
  16757. +
  16758. + __skb_queue_purge(&bearer->m_tx_queue);
  16759. + dect_timer_del(&bearer->tx_timer);
  16760. + dect_bearer_disable(bearer);
  16761. + dect_disable_cipher(trx, &bearer->chd);
  16762. +
  16763. + if (trx->index < 3 &&
  16764. + ((slot >= dect_normal_receive_base(cell->mode) &&
  16765. + slot <= dect_normal_receive_end(cell->mode)) ||
  16766. + (cell->flags & DECT_CELL_MONITOR)))
  16767. + dect_scan_bearer_enable(trx, &bearer->chd);
  16768. +}
  16769. +
  16770. +static void dect_bearer_init(struct dect_cell *cell, struct dect_bearer *bearer,
  16771. + const struct dect_bearer_ops *ops,
  16772. + struct dect_transceiver *trx,
  16773. + const struct dect_channel_desc *chd,
  16774. + enum dect_bearer_modes mode, void *data)
  16775. +{
  16776. + pr_debug("init bearer: mode: %s slot: %u carrier: %u\n",
  16777. + mode == DECT_BEARER_RX ? "RX" : "TX" , chd->slot, chd->carrier);
  16778. +
  16779. + bearer->ops = ops;
  16780. + bearer->trx = trx;
  16781. + bearer->chd = *chd;
  16782. + bearer->mode = mode;
  16783. + bearer->state = DECT_BEARER_INACTIVE;
  16784. + dect_timer_setup(&bearer->tx_timer, NULL, NULL);
  16785. + skb_queue_head_init(&bearer->m_tx_queue);
  16786. + bearer->data = data;
  16787. +
  16788. + trx->slots[chd->slot].bearer = bearer;
  16789. + dect_set_channel_mode(bearer->trx, &bearer->chd, DECT_SLOT_IDLE);
  16790. +}
  16791. +
  16792. +/*
  16793. + * TX bearer activation:
  16794. + *
  16795. + * The first transmission of an outgoing traffic or connectionless bearer is
  16796. + * scheduled for the frame in which the remote sides' scan is on the desired
  16797. + * carrier.
  16798. + *
  16799. + * The noise value of the physical channel must be confirmed not to be more
  16800. + * than 12dBm stronger than the RSSI measurement obtained from the channel
  16801. + * list when selecting the channel within two frames before the first
  16802. + * transmission.
  16803. + *
  16804. + * Dummy bearers are activated immediately after confirming the RSSI.
  16805. + */
  16806. +
  16807. +static void dect_tx_bearer_report_rssi(struct dect_cell *cell,
  16808. + struct dect_bearer *bearer,
  16809. + u8 rssi)
  16810. +{
  16811. + rx_debug(cell, "RSSI confirm: last: %u new: %u\n", bearer->rssi, rssi);
  16812. + if (rssi > bearer->rssi + dect_dbm_to_rssi_rel(12))
  16813. + pr_debug("RSSI: too much noise\n");
  16814. + bearer->state = DECT_BEARER_RSSI_CONFIRMED;
  16815. +}
  16816. +
  16817. +static void dect_tx_bearer_enable_timer(struct dect_cell *cell, void *data)
  16818. +{
  16819. + struct dect_bearer *bearer = data;
  16820. +
  16821. + switch ((int)bearer->state) {
  16822. + case DECT_BEARER_SCHEDULED:
  16823. + tx_debug(cell, "confirm RSSI carrier %u\n", bearer->chd.carrier);
  16824. + dect_set_channel_mode(bearer->trx, &bearer->chd, DECT_SLOT_RX);
  16825. + dect_set_carrier(bearer->trx, bearer->chd.slot, bearer->chd.carrier);
  16826. + dect_bearer_timer_add(cell, bearer, &bearer->tx_timer, 2);
  16827. + bearer->state = DECT_BEARER_RSSI_CONFIRM;
  16828. + break;
  16829. + case DECT_BEARER_RSSI_CONFIRMED:
  16830. + tx_debug(cell, "enable bearer\n");
  16831. + if (bearer->ops->enable != NULL)
  16832. + bearer->ops->enable(cell, bearer);
  16833. + else
  16834. + dect_bearer_enable(bearer);
  16835. + break;
  16836. + }
  16837. +}
  16838. +
  16839. +static void dect_tx_bearer_schedule(struct dect_cell *cell,
  16840. + struct dect_bearer *bearer, u8 rssi)
  16841. +{
  16842. + u8 delay = 0;
  16843. +
  16844. + dect_timer_setup(&bearer->tx_timer, dect_tx_bearer_enable_timer, bearer);
  16845. + if (bearer->ops->state != DECT_DUMMY_BEARER)
  16846. + delay = dect_channel_delay(cell, &bearer->chd) - 2;
  16847. +
  16848. + bearer->state = DECT_BEARER_SCHEDULED;
  16849. + bearer->rssi = rssi;
  16850. +
  16851. + if (delay == 0)
  16852. + dect_tx_bearer_enable_timer(cell, bearer);
  16853. + else {
  16854. + dect_bearer_timer_add(cell, bearer, &bearer->tx_timer, delay);
  16855. + tx_debug(cell, "scheduled bearer: delay %u carrier %u pscn %u\n",
  16856. + delay, bearer->chd.carrier, cell->si.ssi.pscn);
  16857. + }
  16858. +}
  16859. +
  16860. +/*
  16861. + * Broadcast Message Control - decentralized components
  16862. + */
  16863. +
  16864. +/* Paging:
  16865. + *
  16866. + * The following rules apply to page message transmission:
  16867. + *
  16868. + * - Fast pages may be transmitted in any frame and have priority over normal
  16869. + * pages.
  16870. + *
  16871. + * - Normal short and full pages, as well as the first segment of a normal long
  16872. + * page, may only be transmitted in frame 0, or a frame up to 12 if the page
  16873. + * transmitted in the previously allowed frame had the extend bit bit set.
  16874. + *
  16875. + * - Normal pages must be repeated three times in the frames following their
  16876. + * first transmission for page detection in low duty idle mode.
  16877. + *
  16878. + * - Fast pages may be repeated up to three times following their first
  16879. + * transmission. New page message have priority over repetitions.
  16880. + *
  16881. + * FIXME: fast pages should not interrupt repetitions
  16882. + */
  16883. +
  16884. +static void dect_page_timer_schedule(struct dect_cell *cell)
  16885. +{
  16886. + u8 framenum = dect_framenum(cell, DECT_TIMER_TX);
  16887. + u8 frames;
  16888. +
  16889. + if ((framenum & 0x1) == 1)
  16890. + frames = 1;
  16891. + else
  16892. + frames = 2;
  16893. + framenum = dect_framenum_add(framenum, frames);
  16894. +
  16895. + if (framenum == 8 || framenum == 14)
  16896. + frames += 2;
  16897. +
  16898. + tx_debug(cell, "page timer: schedule in %u frames\n", frames);
  16899. + dect_timer_add(cell, &cell->page_timer, DECT_TIMER_TX, frames, 0);
  16900. +}
  16901. +
  16902. +/**
  16903. + * dect_queue_page - Add a paging message to the appropriate queue
  16904. + *
  16905. + * The first transmission of a page is added to the end of the normal or
  16906. + * fast queue. The first three repetitions of normal pages have priority
  16907. + * over first transmissions.
  16908. + */
  16909. +static void dect_queue_page(struct dect_cell *cell, struct sk_buff *skb)
  16910. +{
  16911. + u8 repetitions = DECT_BMC_CB(skb)->repetitions;
  16912. + bool fast = DECT_BMC_CB(skb)->fast_page;
  16913. + struct sk_buff_head *page_queue;
  16914. +
  16915. + page_queue = fast ? &cell->page_fast_queue : &cell->page_queue;
  16916. + if (!fast && repetitions > 0)
  16917. + skb_queue_head(page_queue, skb);
  16918. + else
  16919. + skb_queue_tail(page_queue, skb);
  16920. +
  16921. + dect_page_timer_schedule(cell);
  16922. +}
  16923. +
  16924. +/**
  16925. + * dect_queue_page_segments - perform segmentation and queue the page segments
  16926. + *
  16927. + * Segment a page message into B_S channel sized segments and add them
  16928. + * to the TX queue.
  16929. + */
  16930. +static void dect_queue_page_segments(struct sk_buff_head *list,
  16931. + struct sk_buff *skb)
  16932. +{
  16933. + unsigned int len = skb->len;
  16934. + struct sk_buff *seg;
  16935. + u64 t;
  16936. +
  16937. + while (skb->len > DECT_PT_LFP_BS_DATA_SIZE) {
  16938. + seg = skb_clone(skb, GFP_ATOMIC);
  16939. + if (seg == NULL)
  16940. + goto err;
  16941. + skb_trim(seg, DECT_PT_LFP_BS_DATA_SIZE);
  16942. +
  16943. + if (skb_queue_empty(list))
  16944. + t = DECT_PT_LONG_PAGE_FIRST;
  16945. + else
  16946. + t = DECT_PT_LONG_PAGE;
  16947. +
  16948. + seg->data[0] &= 0x0f;
  16949. + seg->data[0] |= t >> 48;
  16950. + pr_debug("queue page segment len %u hdr %x\n",
  16951. + seg->len, seg->data[0] & 0xf0);
  16952. + __skb_queue_tail(list, seg);
  16953. +
  16954. + skb_pull(skb, DECT_PT_LFP_BS_DATA_SIZE);
  16955. + }
  16956. +
  16957. + /* Short and full pages have the extend bit set in order to reduce
  16958. + * the delay for new pages arriving while a page is already active.
  16959. + */
  16960. + if (skb->len == DECT_PT_SP_BS_DATA_SIZE)
  16961. + t = DECT_PT_SHORT_PAGE | DECT_PT_HDR_EXTEND_FLAG;
  16962. + else if (!DECT_BMC_CB(skb)->long_page)
  16963. + t = DECT_PT_FULL_PAGE | DECT_PT_HDR_EXTEND_FLAG;
  16964. + else if (len == DECT_PT_LFP_BS_DATA_SIZE)
  16965. + t = DECT_PT_LONG_PAGE_ALL;
  16966. + else
  16967. + t = DECT_PT_LONG_PAGE_LAST;
  16968. +
  16969. + skb->data[0] &= 0x0f;
  16970. + skb->data[0] |= t >> 48;
  16971. + pr_debug("queue page segment len %u hdr %x\n",
  16972. + skb->len, skb->data[0] & 0xf0);
  16973. + __skb_queue_tail(list, skb);
  16974. + return;
  16975. +
  16976. +err:
  16977. + __skb_queue_purge(list);
  16978. + kfree_skb(skb);
  16979. +}
  16980. +
  16981. +/**
  16982. + * dect_page_timer - page message transmission timer
  16983. + *
  16984. + * This timer performs maintenance of the page transmit queue. While the queue
  16985. + * is active, it is advanced by one segment per frame. When a page message has
  16986. + * been fully transmitted, the next message is selected for transmission,
  16987. + * segmented into appropriate units and queued to the transmit queue.
  16988. + */
  16989. +static void dect_page_tx_timer(struct dect_cell *cell, void *data)
  16990. +{
  16991. + u32 timeout, mfn = dect_mfn(cell, DECT_TIMER_TX);
  16992. + u8 framenum = dect_framenum(cell, DECT_TIMER_TX);
  16993. + struct sk_buff *skb, *last;
  16994. +
  16995. + tx_debug(cell, "page timer\n");
  16996. +
  16997. + /* Advance the transmit queue by one segment per allowed tail. */
  16998. + if (!skb_queue_empty(&cell->page_tx_queue)) {
  16999. + tx_debug(cell, "advance queue\n");
  17000. + kfree_skb(__skb_dequeue(&cell->page_tx_queue));
  17001. + if (!skb_queue_empty(&cell->page_tx_queue)) {
  17002. + dect_page_timer_schedule(cell);
  17003. + return;
  17004. + }
  17005. + }
  17006. +
  17007. + /* Add the last page back to the queue unless its lifetime expired. */
  17008. + last = cell->page_sdu;
  17009. + if (last != NULL) {
  17010. + cell->page_sdu = NULL;
  17011. +
  17012. + DECT_BMC_CB(last)->repetitions++;
  17013. + timeout = dect_mfn_add(DECT_BMC_CB(last)->stamp, DECT_PAGE_LIFETIME);
  17014. + if (dect_mfn_before(mfn, timeout))
  17015. + dect_queue_page(cell, last);
  17016. + else
  17017. + kfree_skb(last);
  17018. + }
  17019. +
  17020. + /* Get the next page message */
  17021. + while (1) {
  17022. + skb = skb_dequeue(&cell->page_fast_queue);
  17023. + tx_debug(cell, "fast page: %p\n", skb);
  17024. + if (skb == NULL && !skb_queue_empty(&cell->page_queue)) {
  17025. + if (framenum == 0 || (last != NULL && framenum <= 12))
  17026. + skb = skb_dequeue(&cell->page_queue);
  17027. + tx_debug(cell, "normal page: %p\n", skb);
  17028. + }
  17029. + if (skb == NULL)
  17030. + goto out;
  17031. +
  17032. + timeout = dect_mfn_add(DECT_BMC_CB(skb)->stamp, DECT_PAGE_LIFETIME);
  17033. + if (dect_mfn_before(mfn, timeout))
  17034. + break;
  17035. + else
  17036. + kfree_skb(skb);
  17037. + }
  17038. +
  17039. + /* Save a copy of short and full pages for repetitions. */
  17040. + if (!DECT_BMC_CB(skb)->long_page &&
  17041. + DECT_BMC_CB(skb)->repetitions < 3)
  17042. + cell->page_sdu = skb_clone(skb, GFP_ATOMIC);
  17043. +
  17044. + /* Segment page message and queue segments to tx queue */
  17045. + dect_queue_page_segments(&cell->page_tx_queue, skb);
  17046. +out:
  17047. + if (skb != NULL || !skb_queue_empty(&cell->page_queue))
  17048. + dect_page_timer_schedule(cell);
  17049. +}
  17050. +
  17051. +static void dect_cell_schedule_page(struct dect_cell *cell, u32 mask)
  17052. +{
  17053. + struct dect_bc *bc;
  17054. +
  17055. + list_for_each_entry(bc, &cell->bcs, list)
  17056. + bc->p_tx_mask |= mask;
  17057. +}
  17058. +
  17059. +static void dect_cell_bmc_init(struct dect_cell *cell)
  17060. +{
  17061. + skb_queue_head_init(&cell->page_queue);
  17062. + skb_queue_head_init(&cell->page_fast_queue);
  17063. + skb_queue_head_init(&cell->page_tx_queue);
  17064. + dect_timer_setup(&cell->page_timer, dect_page_tx_timer, NULL);
  17065. +}
  17066. +
  17067. +static void dect_cell_bmc_disable(struct dect_cell *cell)
  17068. +{
  17069. + dect_timer_del(&cell->page_timer);
  17070. + __skb_queue_purge(&cell->page_tx_queue);
  17071. + __skb_queue_purge(&cell->page_fast_queue);
  17072. + __skb_queue_purge(&cell->page_queue);
  17073. +}
  17074. +
  17075. +/*
  17076. + * Broadcast Control
  17077. + */
  17078. +
  17079. +static void dect_cell_mac_info_ind(struct dect_cell *cell)
  17080. +{
  17081. + const struct dect_cluster_handle *clh = cell->handle.clh;
  17082. +
  17083. + clh->ops->mac_info_ind(clh, &cell->idi, &cell->si);
  17084. +}
  17085. +
  17086. +static u32 dect_build_page_rfpi(const struct dect_cell *cell)
  17087. +{
  17088. + return (dect_build_rfpi(&cell->idi) >> 24) & ((1 << 20) - 1);
  17089. +}
  17090. +
  17091. +static void dect_bc_release(struct dect_bc *bc)
  17092. +{
  17093. + kfree_skb(bc->p_rx_skb);
  17094. + list_del(&bc->list);
  17095. +}
  17096. +
  17097. +static void dect_bc_init(struct dect_cell *cell, struct dect_bc *bc)
  17098. +{
  17099. + INIT_LIST_HEAD(&bc->list);
  17100. + bc->p_rx_skb = NULL;
  17101. + list_add_tail(&bc->list, &cell->bcs);
  17102. +}
  17103. +
  17104. +static const enum dect_mac_system_information_types dect_bc_q_cycle[] = {
  17105. + DECT_QT_SI_SSI,
  17106. + DECT_QT_SI_ERFC,
  17107. + DECT_QT_SI_SARI,
  17108. + DECT_QT_SI_FPC,
  17109. + DECT_QT_SI_EFPC,
  17110. + DECT_QT_SI_EFPC2,
  17111. + DECT_QT_SI_MFN,
  17112. +};
  17113. +
  17114. +static struct sk_buff *dect_bc_q_dequeue(struct dect_cell *cell,
  17115. + struct dect_bearer *bearer)
  17116. +{
  17117. + const struct dect_si *si = &cell->si;
  17118. + struct dect_ssi ssi;
  17119. + struct dect_mfn mfn;
  17120. + struct sk_buff *skb;
  17121. + unsigned int index;
  17122. +
  17123. + skb = dect_t_skb_alloc();
  17124. + if (skb == NULL)
  17125. + return NULL;
  17126. +
  17127. + while (1) {
  17128. + index = cell->si_idx++;
  17129. + if (cell->si_idx == ARRAY_SIZE(dect_bc_q_cycle))
  17130. + cell->si_idx = 0;
  17131. +
  17132. + switch (dect_bc_q_cycle[index]) {
  17133. + case DECT_QT_SI_SSI:
  17134. + memcpy(&ssi, &si->ssi, sizeof(ssi));
  17135. + ssi.sn = bearer->chd.slot;
  17136. + ssi.cn = bearer->chd.carrier;
  17137. + ssi.sp = 0;
  17138. + ssi.pscn = dect_next_carrier(ssi.rfcars, ssi.pscn);
  17139. +
  17140. + return dect_build_tail_msg(skb, DECT_TM_TYPE_SSI, &ssi);
  17141. + case DECT_QT_SI_ERFC:
  17142. + if (!si->ssi.mc)
  17143. + continue;
  17144. + return dect_build_tail_msg(skb, DECT_TM_TYPE_ERFC,
  17145. + &si->erfc);
  17146. + case DECT_QT_SI_SARI:
  17147. + break;
  17148. + case DECT_QT_SI_FPC:
  17149. + return dect_build_tail_msg(skb, DECT_TM_TYPE_FPC,
  17150. + &si->fpc);
  17151. + case DECT_QT_SI_EFPC:
  17152. + if (!(si->fpc.fpc & DECT_FPC_EXTENDED_FP_INFO))
  17153. + continue;
  17154. + return dect_build_tail_msg(skb, DECT_TM_TYPE_EFPC,
  17155. + &si->efpc);
  17156. + case DECT_QT_SI_EFPC2:
  17157. + if (!(si->efpc.fpc & DECT_EFPC_EXTENDED_FP_INFO2))
  17158. + continue;
  17159. + return dect_build_tail_msg(skb, DECT_TM_TYPE_EFPC2,
  17160. + &si->efpc2);
  17161. + case DECT_QT_SI_MFN:
  17162. + mfn.num = dect_mfn(cell, DECT_TIMER_TX);
  17163. + return dect_build_tail_msg(skb, DECT_TM_TYPE_MFN, &mfn);
  17164. + default:
  17165. + BUG();
  17166. + }
  17167. + }
  17168. +}
  17169. +
  17170. +static void dect_page_add_mac_info(struct dect_cell *cell, struct dect_bc *bc,
  17171. + struct sk_buff *skb)
  17172. +{
  17173. + struct dect_tail_msg tm;
  17174. + struct dect_dbc *dbc;
  17175. + u64 t;
  17176. + u8 *it;
  17177. +
  17178. + memset(&tm, 0, sizeof(tm));
  17179. + if (bc->p_tx_mask & (1 << DECT_TM_TYPE_BFS))
  17180. + tm.type = DECT_TM_TYPE_BFS;
  17181. + else if (bc->p_tx_mask & (1 << DECT_TM_TYPE_BD))
  17182. + tm.type = DECT_TM_TYPE_BD;
  17183. + else
  17184. + tm.type = DECT_TM_TYPE_ACTIVE_CARRIERS;
  17185. +
  17186. + switch (tm.type) {
  17187. + case DECT_TM_TYPE_BFS:
  17188. + tm.bfs.mask = cell->trg_blind_full_slots;
  17189. + t = dect_build_blind_full_slots(&tm.bfs);
  17190. + break;
  17191. + case DECT_TM_TYPE_BD:
  17192. + dbc = dect_dbc_get(cell);
  17193. + if (dbc == NULL)
  17194. + goto out;
  17195. + tm.bd.bt = DECT_PT_IT_DUMMY_OR_CL_BEARER_POSITION;
  17196. + tm.bd.sn = dbc->bearer.chd.slot;
  17197. + tm.bd.sp = 0;
  17198. + tm.bd.cn = dbc->bearer.chd.carrier;
  17199. + t = dect_build_bearer_description(&tm.bd);
  17200. + break;
  17201. + case DECT_TM_TYPE_RFP_ID:
  17202. + t = dect_build_rfp_identity(&tm.rfp_id);
  17203. + break;
  17204. + case DECT_TM_TYPE_RFP_STATUS:
  17205. + t = dect_build_rfp_status(&tm.rfp_status);
  17206. + break;
  17207. + case DECT_TM_TYPE_ACTIVE_CARRIERS:
  17208. + default:
  17209. + t = dect_build_active_carriers(&tm.active_carriers);
  17210. + break;
  17211. + }
  17212. +
  17213. + it = skb_put(skb, DECT_PT_INFO_TYPE_SIZE);
  17214. + it[0] = t >> 24;
  17215. + it[1] = t >> 16;
  17216. +out:
  17217. + bc->p_tx_mask &= ~(1 << tm.type);
  17218. +}
  17219. +
  17220. +static struct sk_buff *dect_bc_p_dequeue(struct dect_cell *cell,
  17221. + struct dect_bearer *bearer,
  17222. + struct dect_bc *bc)
  17223. +{
  17224. + unsigned int headroom, tailroom = 0;
  17225. + struct sk_buff *skb;
  17226. + u8 *hdr;
  17227. + u64 t;
  17228. +
  17229. + /* Send higher layer page messages if present */
  17230. + skb = skb_peek(&cell->page_tx_queue);
  17231. + if (skb != NULL) {
  17232. + /* The frame needs headroom for the preamble and hdr-field.
  17233. + * Short pages need additional tailroom for the MAC Layer
  17234. + * Information. */
  17235. + headroom = DECT_PREAMBLE_SIZE + DECT_HDR_FIELD_SIZE;
  17236. + if (skb->len == DECT_PT_SP_BS_DATA_SIZE)
  17237. + tailroom = DECT_PT_INFO_TYPE_SIZE;
  17238. +
  17239. + skb = skb_copy_expand(skb, headroom, tailroom, GFP_ATOMIC);
  17240. + if (skb == NULL)
  17241. + return NULL;
  17242. + /* Reserve space for preamble */
  17243. + skb_set_mac_header(skb, -headroom);
  17244. + } else {
  17245. + /* Send zero-length page if required */
  17246. + if (dect_framenum(cell, DECT_TIMER_TX) == 0 ||
  17247. + bc->p_tx_mask == 0)
  17248. + return NULL;
  17249. +
  17250. + skb = dect_t_skb_alloc();
  17251. + if (skb == NULL)
  17252. + return NULL;
  17253. +
  17254. + t = DECT_PT_ZERO_PAGE | DECT_PT_HDR_EXTEND_FLAG;
  17255. + t |= (u64)dect_build_page_rfpi(cell) << DECT_PT_ZP_RFPI_SHIFT;
  17256. +
  17257. + hdr = skb_put(skb, 3);
  17258. + hdr[0] = t >> 48;
  17259. + hdr[1] = t >> 40;
  17260. + hdr[2] = t >> 32;
  17261. +
  17262. + tailroom = DECT_PT_INFO_TYPE_SIZE;
  17263. + }
  17264. +
  17265. + DECT_A_CB(skb)->id = DECT_TI_PT;
  17266. + if (tailroom > 0)
  17267. + dect_page_add_mac_info(cell, bc, skb);
  17268. +
  17269. + return skb;
  17270. +}
  17271. +
  17272. +static struct sk_buff *dect_bc_dequeue(struct dect_cell *cell,
  17273. + struct dect_bearer *bearer,
  17274. + struct dect_bc *bc,
  17275. + enum dect_mac_channels chan)
  17276. +{
  17277. + struct sk_buff *skb;
  17278. +
  17279. + switch (chan) {
  17280. + case DECT_MC_P:
  17281. + return dect_bc_p_dequeue(cell, bearer, bc);
  17282. + case DECT_MC_Q:
  17283. + return dect_bc_q_dequeue(cell, bearer);
  17284. + case DECT_MC_N:
  17285. + skb = dect_t_skb_alloc();
  17286. + if (skb == NULL)
  17287. + return NULL;
  17288. + return dect_build_tail_msg(skb, DECT_TM_TYPE_ID, &cell->idi);
  17289. + default:
  17290. + BUG();
  17291. + }
  17292. +}
  17293. +
  17294. +/**
  17295. + * dect_bc_queue_bs_data - queue a page message to the broadcast controller for
  17296. + * reassembly and delivery to broadcast message control.
  17297. + *
  17298. + * @cell: DECT cell
  17299. + * @bc: broadcast controller
  17300. + * @skb_in: DECT frame
  17301. + * @page: page message
  17302. + */
  17303. +static void dect_bc_queue_bs_data(struct dect_cell *cell, struct dect_bc *bc,
  17304. + struct sk_buff *skb_in, const struct dect_page *page)
  17305. +{
  17306. + const struct dect_cluster_handle *clh = cell->handle.clh;
  17307. + struct sk_buff *skb, *head;
  17308. +
  17309. + if (page->length == DECT_PT_ZERO_PAGE)
  17310. + return;
  17311. +
  17312. + skb = skb_clone(skb_in, GFP_ATOMIC);
  17313. + if (skb == NULL)
  17314. + return;
  17315. + skb_pull(skb, DECT_T_FIELD_OFF);
  17316. + DECT_BMC_CB(skb)->long_page = false;
  17317. +
  17318. + head = bc->p_rx_skb;
  17319. + switch (page->length) {
  17320. + case DECT_PT_SHORT_PAGE:
  17321. + skb_trim(skb, DECT_PT_SP_BS_DATA_SIZE);
  17322. + break;
  17323. + case DECT_PT_LONG_PAGE_ALL:
  17324. + DECT_BMC_CB(skb)->long_page = true;
  17325. + /* fall through */
  17326. + case DECT_PT_FULL_PAGE:
  17327. + skb_trim(skb, DECT_PT_LFP_BS_DATA_SIZE);
  17328. + break;
  17329. + case DECT_PT_LONG_PAGE_FIRST:
  17330. + if (head != NULL)
  17331. + goto err_free;
  17332. + DECT_BMC_CB(skb)->long_page = true;
  17333. + skb_trim(skb, DECT_PT_LFP_BS_DATA_SIZE);
  17334. + bc->p_rx_skb = skb;
  17335. + return;
  17336. + case DECT_PT_LONG_PAGE:
  17337. + if (head == NULL)
  17338. + goto err_free;
  17339. + skb_trim(skb, DECT_PT_LFP_BS_DATA_SIZE);
  17340. + skb_append_frag(head, skb);
  17341. + if (head->len >= 30)
  17342. + goto err;
  17343. + return;
  17344. + case DECT_PT_LONG_PAGE_LAST:
  17345. + if (head == NULL)
  17346. + goto err_free;
  17347. + skb_trim(skb, DECT_PT_LFP_BS_DATA_SIZE);
  17348. + skb = skb_append_frag(head, skb);
  17349. + bc->p_rx_skb = NULL;
  17350. + break;
  17351. + default:
  17352. + BUG();
  17353. + }
  17354. +
  17355. + return clh->ops->bmc_page_ind(clh, skb);
  17356. +
  17357. +err_free:
  17358. + kfree_skb(skb);
  17359. +err:
  17360. + kfree_skb(bc->p_rx_skb);
  17361. + bc->p_rx_skb = NULL;
  17362. +}
  17363. +
  17364. +static bool dect_bc_update_si(struct dect_si *si,
  17365. + const struct dect_tail_msg *tm)
  17366. +{
  17367. + bool notify = false;
  17368. + unsigned int i;
  17369. +
  17370. + switch (tm->type) {
  17371. + case DECT_TM_TYPE_SSI:
  17372. + if (memcmp(&si->ssi, &tm->ssi, sizeof(si->ssi)))
  17373. + memcpy(&si->ssi, &tm->ssi, sizeof(si->ssi));
  17374. + break;
  17375. + case DECT_TM_TYPE_ERFC:
  17376. + if (memcmp(&si->erfc, &tm->erfc, sizeof(si->erfc)))
  17377. + memcpy(&si->erfc, &tm->erfc, sizeof(si->erfc));
  17378. + break;
  17379. + case DECT_TM_TYPE_FPC:
  17380. + if (memcmp(&si->fpc, &tm->fpc, sizeof(si->fpc))) {
  17381. + memcpy(&si->fpc, &tm->fpc, sizeof(si->fpc));
  17382. + notify = true;
  17383. + }
  17384. + break;
  17385. + case DECT_TM_TYPE_EFPC:
  17386. + if (memcmp(&si->efpc, &tm->efpc, sizeof(si->efpc))) {
  17387. + memcpy(&si->efpc, &tm->efpc, sizeof(si->efpc));
  17388. + notify = true;
  17389. + }
  17390. + break;
  17391. + case DECT_TM_TYPE_EFPC2:
  17392. + if (memcmp(&si->efpc2, &tm->efpc2, sizeof(si->efpc2))) {
  17393. + memcpy(&si->efpc2, &tm->efpc2, sizeof(si->efpc2));
  17394. + notify = true;
  17395. + }
  17396. + break;
  17397. + case DECT_TM_TYPE_SARI:
  17398. + if (si->num_saris == ARRAY_SIZE(si->sari))
  17399. + break;
  17400. +
  17401. + for (i = 0; i < si->num_saris; i++) {
  17402. + if (!dect_ari_cmp(&tm->sari.ari, &si->sari[i].ari))
  17403. + break;
  17404. + }
  17405. + if (i < si->num_saris)
  17406. + break;
  17407. +
  17408. + memcpy(&si->sari[si->num_saris++], &tm->sari,
  17409. + sizeof(si->sari[i]));
  17410. + notify = true;
  17411. + break;
  17412. + case DECT_TM_TYPE_MFN:
  17413. + memcpy(&si->mfn, &tm->mfn, sizeof(si->mfn));
  17414. + break;
  17415. + default:
  17416. + return false;
  17417. + }
  17418. +
  17419. + si->mask |= 1 << tm->type;
  17420. + return notify;
  17421. +}
  17422. +
  17423. +static bool dect_bc_si_cycle_complete(struct dect_idi *idi,
  17424. + const struct dect_si *si)
  17425. +{
  17426. + if (!(si->mask & (1 << DECT_TM_TYPE_SSI))) {
  17427. + pr_debug("incomplete: SSI\n");
  17428. + return false;
  17429. + }
  17430. + if (si->ssi.mc &&
  17431. + !(si->mask & (1 << DECT_TM_TYPE_ERFC))) {
  17432. + pr_debug("incomplete: ERFC\n");
  17433. + return false;
  17434. + }
  17435. +
  17436. + if (!(si->mask & (1 << DECT_TM_TYPE_FPC))) {
  17437. + pr_debug("incomplete: FPC\n");
  17438. + return false;
  17439. + }
  17440. + if (si->fpc.fpc & DECT_FPC_EXTENDED_FP_INFO &&
  17441. + !(si->mask & (1 << DECT_TM_TYPE_EFPC))) {
  17442. + pr_debug("incomplete: EFPC\n");
  17443. + return false;
  17444. + }
  17445. +
  17446. + if (si->mask & (1 << DECT_TM_TYPE_EFPC) &&
  17447. + si->efpc.fpc & DECT_EFPC_EXTENDED_FP_INFO2 &&
  17448. + !(si->mask & (1 << DECT_TM_TYPE_EFPC2))) {
  17449. + pr_debug("incomplete: EFPC2\n");
  17450. + return false;
  17451. + }
  17452. +
  17453. + if (idi->e &&
  17454. + (!(si->mask & (1 << DECT_TM_TYPE_SARI)) ||
  17455. + si->num_saris != si->sari[0].list_cycle)) {
  17456. + pr_debug("incomplete: SARI\n");
  17457. + return false;
  17458. + }
  17459. +
  17460. + pr_debug("complete\n");
  17461. + return true;
  17462. +}
  17463. +
  17464. +static void dect_bc_rcv(struct dect_cell *cell, struct dect_bc *bc,
  17465. + struct sk_buff *skb, const struct dect_tail_msg *tm)
  17466. +{
  17467. + enum dect_tail_identifications ti;
  17468. + bool notify;
  17469. +
  17470. + if (cell->mode != DECT_MODE_PP)
  17471. + return;
  17472. +
  17473. + ti = dect_parse_tail(skb);
  17474. + if (ti == DECT_TI_QT) {
  17475. + /* Q-channel information is broadcast in frame 8 */
  17476. + dect_timer_synchronize_framenum(cell, DECT_Q_CHANNEL_FRAME);
  17477. + if (tm->type == DECT_TM_TYPE_MFN)
  17478. + dect_timer_synchronize_mfn(cell, tm->mfn.num);
  17479. +
  17480. + notify = dect_bc_update_si(&cell->si, tm);
  17481. + if (dect_bc_si_cycle_complete(&cell->idi, &cell->si) && notify)
  17482. + dect_cell_mac_info_ind(cell);
  17483. + } else if (ti == DECT_TI_PT) {
  17484. + if (tm->page.length == DECT_PT_ZERO_PAGE &&
  17485. + tm->page.rfpi != dect_build_page_rfpi(cell))
  17486. + pr_debug("RFPI mismatch %.3x %.3x\n",
  17487. + tm->page.rfpi, dect_build_page_rfpi(cell));
  17488. + }
  17489. +
  17490. + switch (tm->type) {
  17491. + case DECT_TM_TYPE_BFS:
  17492. + cell->blind_full_slots = tm->bfs.mask;
  17493. + case DECT_TM_TYPE_BD:
  17494. + case DECT_TM_TYPE_RFP_ID:
  17495. + case DECT_TM_TYPE_RFP_STATUS:
  17496. + case DECT_TM_TYPE_ACTIVE_CARRIERS:
  17497. + case DECT_TM_TYPE_PAGE:
  17498. + dect_bc_queue_bs_data(cell, bc, skb, &tm->page);
  17499. + break;
  17500. + default:
  17501. + break;
  17502. + }
  17503. +}
  17504. +
  17505. +/*
  17506. + * Traffic Bearer Control (TBC)
  17507. + */
  17508. +
  17509. +#define tbc_debug(tbc, fmt, args...) \
  17510. + pr_debug("TBC (TBEI %u/%s): PMID: %s %x FMID: %.3x: " fmt, \
  17511. + (tbc)->id.tbei, tbc_states[(tbc)->state], \
  17512. + (tbc)->id.pmid.type == DECT_PMID_DEFAULT ? "default" : \
  17513. + (tbc)->id.pmid.type == DECT_PMID_ASSIGNED ? "assigned" : \
  17514. + (tbc)->id.pmid.type == DECT_PMID_EMERGENCY ? "emergency" : "?", \
  17515. + (tbc)->id.pmid.tpui, (tbc)->cell->fmid, ## args);
  17516. +
  17517. +static const char *tbc_states[] = {
  17518. + [DECT_TBC_NONE] = "NONE",
  17519. + [DECT_TBC_REQ_SENT] = "REQ_SENT",
  17520. + [DECT_TBC_WAIT_RCVD] = "WAIT_RCVD",
  17521. + [DECT_TBC_REQ_RCVD] = "REQ_RCVD",
  17522. + [DECT_TBC_RESPONSE_SENT] = "RESPONSE_SENT",
  17523. + [DECT_TBC_ATTRIBUTES_SENT] = "ATTRIBUTES_SENT",
  17524. + [DECT_TBC_OTHER_WAIT] = "OTHER_WAIT",
  17525. + [DECT_TBC_ESTABLISHED] = "ESTABLISHED",
  17526. + [DECT_TBC_RELEASING] = "RELEASING",
  17527. + [DECT_TBC_RELEASED] = "RELEASED",
  17528. +};
  17529. +
  17530. +static struct sk_buff *dect_b_skb_alloc(const struct dect_channel_desc *chd)
  17531. +{
  17532. + unsigned int b_field_size;
  17533. + struct sk_buff *skb;
  17534. +
  17535. + b_field_size = dect_pkt_b_field_size(chd);
  17536. + skb = alloc_skb(b_field_size, GFP_ATOMIC);
  17537. + if (skb == NULL)
  17538. + return NULL;
  17539. + skb_put(skb, b_field_size);
  17540. + memset(skb->data, 0xff, b_field_size);
  17541. + return skb;
  17542. +}
  17543. +
  17544. +static enum dect_b_identifications dect_pkt_to_bi(enum dect_packet_types pkt)
  17545. +{
  17546. + switch (pkt) {
  17547. + case DECT_PACKET_P08:
  17548. + return DECT_BI_HALF_SLOT_REQUIRED;
  17549. + case DECT_PACKET_P80:
  17550. + return DECT_BI_DOUBLE_SLOT_REQUIRED;
  17551. + case DECT_PACKET_P640j:
  17552. + return DECT_BI_LONG_SLOT_640_REQUIRED;
  17553. + case DECT_PACKET_P672j:
  17554. + return DECT_BI_LONG_SLOT_672_REQUIRED;
  17555. + default:
  17556. + return DECT_BI_NONE;
  17557. + }
  17558. +}
  17559. +
  17560. +static enum dect_packet_types dect_bi_to_pkt(enum dect_b_identifications b_id)
  17561. +{
  17562. + switch (b_id) {
  17563. + case DECT_BI_DOUBLE_SLOT_REQUIRED:
  17564. + return DECT_PACKET_P80;
  17565. + case DECT_BI_HALF_SLOT_REQUIRED:
  17566. + return DECT_PACKET_P08;
  17567. + case DECT_BI_LONG_SLOT_672_REQUIRED:
  17568. + return DECT_PACKET_P672j;
  17569. + case DECT_BI_LONG_SLOT_640_REQUIRED:
  17570. + return DECT_PACKET_P640j;
  17571. + default:
  17572. + return DECT_PACKET_P32;
  17573. + }
  17574. +}
  17575. +
  17576. +static struct dect_tbc *dect_tbc_get_by_tbei(const struct dect_cell *cell, u32 tbei)
  17577. +{
  17578. + struct dect_tbc *tbc;
  17579. +
  17580. + list_for_each_entry(tbc, &cell->tbcs, list) {
  17581. + if (tbc->id.tbei == tbei)
  17582. + return tbc;
  17583. + }
  17584. + return NULL;
  17585. +}
  17586. +
  17587. +static u32 dect_tbc_alloc_tbei(struct dect_cell *cell)
  17588. +{
  17589. + u32 tbei;
  17590. +
  17591. + while (1) {
  17592. + tbei = ++cell->tbei_rover;
  17593. + if (tbei == 0)
  17594. + continue;
  17595. + if (dect_tbc_get_by_tbei(cell, tbei))
  17596. + continue;
  17597. + return tbei;
  17598. + }
  17599. +}
  17600. +
  17601. +static void dect_tbc_queue_mac_control(struct dect_tbc *tbc, struct sk_buff *skb)
  17602. +{
  17603. + skb_queue_tail(&tbc->txb.m_tx_queue, skb);
  17604. +}
  17605. +
  17606. +static struct sk_buff *dect_tbc_build_cctrl(const struct dect_tbc *tbc,
  17607. + enum dect_cctrl_cmds cmd)
  17608. +{
  17609. + struct dect_cctrl cctl;
  17610. + struct sk_buff *skb;
  17611. +
  17612. + skb = dect_t_skb_alloc();
  17613. + if (skb == NULL)
  17614. + return NULL;
  17615. +
  17616. + cctl.fmid = tbc->cell->fmid;
  17617. + cctl.pmid = dect_build_pmid(&tbc->id.pmid);
  17618. + cctl.cmd = cmd;
  17619. +
  17620. + if (tbc->mcp.type == DECT_MAC_CONN_BASIC)
  17621. + return dect_build_tail_msg(skb, DECT_TM_TYPE_BCCTRL, &cctl);
  17622. + else
  17623. + return dect_build_tail_msg(skb, DECT_TM_TYPE_ACCTRL, &cctl);
  17624. +}
  17625. +
  17626. +static struct sk_buff *dect_tbc_build_encctrl(const struct dect_tbc *tbc,
  17627. + enum dect_encctrl_cmds cmd)
  17628. +{
  17629. + struct dect_encctrl ectl;
  17630. + struct sk_buff *skb;
  17631. +
  17632. + skb = dect_t_skb_alloc();
  17633. + if (skb == NULL)
  17634. + return NULL;
  17635. +
  17636. + ectl.fmid = tbc->cell->fmid;
  17637. + ectl.pmid = dect_build_pmid(&tbc->id.pmid);
  17638. + ectl.cmd = cmd;
  17639. +
  17640. + return dect_build_tail_msg(skb, DECT_TM_TYPE_ENCCTRL, &ectl);
  17641. +}
  17642. +
  17643. +static int dect_tbc_send_confirm(struct dect_tbc *tbc)
  17644. +{
  17645. + struct sk_buff *skb;
  17646. +
  17647. + tbc_debug(tbc, "TX CONFIRM\n");
  17648. + skb = dect_tbc_build_cctrl(tbc, DECT_CCTRL_BEARER_CONFIRM);
  17649. + if (skb == NULL)
  17650. + return -ENOMEM;
  17651. +
  17652. + /* The first response is permitted in any frame */
  17653. + if (tbc->state == DECT_TBC_REQ_RCVD)
  17654. + skb->priority = DECT_MT_HIGH_PRIORITY;
  17655. + dect_tbc_queue_mac_control(tbc, skb);
  17656. + return 0;
  17657. +}
  17658. +
  17659. +static int dect_tbc_send_attributes(struct dect_tbc *tbc, enum dect_cctrl_cmds cmd)
  17660. +{
  17661. + struct dect_cctrl cctl;
  17662. + struct sk_buff *skb;
  17663. +
  17664. + skb = dect_t_skb_alloc();
  17665. + if (skb == NULL)
  17666. + return -ENOMEM;
  17667. +
  17668. + cctl.cmd = cmd;
  17669. + cctl.attr.ecn = tbc->id.ecn;
  17670. + cctl.attr.lbn = tbc->id.lbn;
  17671. + cctl.attr.type = DECT_CCTRL_TYPE_SYMETRIC_BEARER;
  17672. + cctl.attr.service = tbc->mcp.service;
  17673. + cctl.attr.cf = false;
  17674. +
  17675. + cctl.attr.slot = tbc->mcp.slot;
  17676. + cctl.attr.a_mod = DECT_MODULATION_2_LEVEL;
  17677. + cctl.attr.bz_mod = DECT_MODULATION_2_LEVEL;
  17678. + cctl.attr.bz_ext_mod = 7;
  17679. + cctl.attr.acr = 0;
  17680. +
  17681. + if (tbc->mcp.type == DECT_MAC_CONN_BASIC)
  17682. + dect_build_tail_msg(skb, DECT_TM_TYPE_BCCTRL, &cctl);
  17683. + else
  17684. + dect_build_tail_msg(skb, DECT_TM_TYPE_ACCTRL, &cctl);
  17685. +
  17686. + dect_tbc_queue_mac_control(tbc, skb);
  17687. + return 0;
  17688. +}
  17689. +
  17690. +static int dect_tbc_send_attributes_confirm(struct dect_tbc *tbc)
  17691. +{
  17692. + tbc_debug(tbc, "TX ATTRIBUTES_T_CONFIRM\n");
  17693. + return dect_tbc_send_attributes(tbc, DECT_CCTRL_ATTRIBUTES_T_CONFIRM);
  17694. +}
  17695. +
  17696. +static int dect_tbc_send_attributes_request(struct dect_tbc *tbc)
  17697. +{
  17698. + tbc_debug(tbc, "TX ATTRIBUTES_T_REQUEST\n");
  17699. + return dect_tbc_send_attributes(tbc, DECT_CCTRL_ATTRIBUTES_T_REQUEST);
  17700. +}
  17701. +
  17702. +static int dect_tbc_send_wait(struct dect_tbc *tbc)
  17703. +{
  17704. + struct sk_buff *skb;
  17705. +
  17706. + skb = dect_tbc_build_cctrl(tbc, DECT_CCTRL_WAIT);
  17707. + if (skb == NULL)
  17708. + return -ENOMEM;
  17709. + dect_tbc_queue_mac_control(tbc, skb);
  17710. + return 0;
  17711. +}
  17712. +
  17713. +static int dect_tbc_send_release(struct dect_tbc *tbc,
  17714. + enum dect_release_reasons reason)
  17715. +{
  17716. + struct dect_cctrl cctl;
  17717. + struct sk_buff *skb;
  17718. +
  17719. + tbc_debug(tbc, "TX RELEASE: reason: %x\n", reason);
  17720. + skb = dect_t_skb_alloc();
  17721. + if (skb == NULL)
  17722. + return -ENOMEM;
  17723. +
  17724. + cctl.cmd = DECT_CCTRL_RELEASE;
  17725. + cctl.pmid = dect_build_pmid(&tbc->id.pmid);
  17726. + cctl.rel.reason = reason;
  17727. +
  17728. + if (tbc->mcp.type == DECT_MAC_CONN_BASIC)
  17729. + dect_build_tail_msg(skb, DECT_TM_TYPE_BCCTRL, &cctl);
  17730. + else
  17731. + dect_build_tail_msg(skb, DECT_TM_TYPE_ACCTRL, &cctl);
  17732. +
  17733. + /* RELEASE messages may appear in any frame */
  17734. + skb->priority = DECT_MT_HIGH_PRIORITY;
  17735. + dect_tbc_queue_mac_control(tbc, skb);
  17736. + return 0;
  17737. +}
  17738. +
  17739. +static void dect_tbc_state_change(struct dect_tbc *tbc, enum dect_tbc_state state)
  17740. +{
  17741. + struct dect_cell *cell = tbc->cell;
  17742. +
  17743. + tbc_debug(tbc, "state change: %s (%u) -> %s (%u)\n",
  17744. + tbc_states[tbc->state], tbc->state, tbc_states[state], state);
  17745. +
  17746. + if (tbc->state == DECT_TBC_ESTABLISHED) {
  17747. + cell->tbc_num_est--;
  17748. + cell->tbc_last_chd = tbc->rxb.chd;
  17749. + } else if (state == DECT_TBC_ESTABLISHED)
  17750. + cell->tbc_num_est++;
  17751. +
  17752. + tbc->state = state;
  17753. +}
  17754. +
  17755. +static int dect_tbc_event(const struct dect_tbc *tbc, enum dect_tbc_event event)
  17756. +{
  17757. + const struct dect_cluster_handle *clh = tbc->cell->handle.clh;
  17758. +
  17759. + return clh->ops->tbc_event_ind(clh, &tbc->id, event);
  17760. +}
  17761. +
  17762. +static int dect_tbc_establish_cfm(const struct dect_tbc *tbc, bool success)
  17763. +{
  17764. + const struct dect_cluster_handle *clh = tbc->cell->handle.clh;
  17765. +
  17766. + return clh->ops->tbc_establish_cfm(clh, &tbc->id, success,
  17767. + tbc->rxb.chd.slot);
  17768. +}
  17769. +
  17770. +static void dect_tbc_release_notify(const struct dect_tbc *tbc,
  17771. + enum dect_release_reasons reason)
  17772. +{
  17773. + const struct dect_cluster_handle *clh = tbc->cell->handle.clh;
  17774. +
  17775. + clh->ops->tbc_dis_ind(clh, &tbc->id, reason);
  17776. +}
  17777. +
  17778. +static void dect_tdd_channel_desc(struct dect_channel_desc *dst,
  17779. + const struct dect_channel_desc *chd)
  17780. +{
  17781. + dst->pkt = chd->pkt;
  17782. + dst->b_fmt = chd->b_fmt;
  17783. + dst->carrier = chd->carrier;
  17784. + dst->slot = dect_tdd_slot(chd->slot);
  17785. +}
  17786. +
  17787. +static void dect_tbc_destroy(struct dect_cell *cell, struct dect_tbc *tbc)
  17788. +{
  17789. + tbc_debug(tbc, "destroy\n");
  17790. + dect_tbc_state_change(tbc, DECT_TBC_NONE);
  17791. +
  17792. + dect_timer_del(&tbc->wd_timer);
  17793. + dect_timer_del(&tbc->wait_timer);
  17794. + dect_timer_del(&tbc->release_timer);
  17795. + dect_timer_del(&tbc->enc_timer);
  17796. + dect_bc_release(&tbc->bc);
  17797. +
  17798. + dect_channel_release(cell, tbc->txb.trx, &tbc->txb.chd);
  17799. + dect_bearer_release(cell, &tbc->txb);
  17800. +
  17801. + dect_channel_release(cell, tbc->rxb.trx, &tbc->rxb.chd);
  17802. + dect_bearer_release(cell, &tbc->rxb);
  17803. +
  17804. + list_del(&tbc->list);
  17805. + kfree_skb(tbc->cs_tx_skb);
  17806. + kfree(tbc);
  17807. +}
  17808. +
  17809. +static void dect_tbc_release_timer(struct dect_cell *cell, void *data)
  17810. +{
  17811. + struct dect_tbc *tbc = data;
  17812. +
  17813. + switch (tbc->state) {
  17814. + default:
  17815. + dect_tbc_state_change(tbc, DECT_TBC_RELEASING);
  17816. + break;
  17817. + case DECT_TBC_RELEASING:
  17818. + dect_tbc_state_change(tbc, DECT_TBC_RELEASED);
  17819. + break;
  17820. + case DECT_TBC_NONE:
  17821. + case DECT_TBC_REQ_SENT:
  17822. + case DECT_TBC_RELEASED:
  17823. + return dect_tbc_destroy(cell, tbc);
  17824. + }
  17825. +
  17826. + dect_tbc_send_release(tbc, tbc->release_reason);
  17827. + dect_bearer_timer_add(tbc->cell, &tbc->txb, &tbc->release_timer,
  17828. + DECT_MT_FRAME_RATE);
  17829. +}
  17830. +
  17831. +static void dect_tbc_begin_release(struct dect_cell *cell, struct dect_tbc *tbc,
  17832. + enum dect_release_reasons reason)
  17833. +{
  17834. + tbc->release_reason = reason;
  17835. + dect_tbc_release_timer(cell, tbc);
  17836. +}
  17837. +
  17838. +static void dect_tbc_dis_req(const struct dect_cell_handle *ch,
  17839. + const struct dect_tbc_id *id,
  17840. + enum dect_release_reasons reason)
  17841. +{
  17842. + struct dect_cell *cell = dect_cell(ch);
  17843. + struct dect_tbc *tbc;
  17844. +
  17845. + tbc = dect_tbc_get_by_tbei(cell, id->tbei);
  17846. + if (tbc == NULL)
  17847. + return;
  17848. + tbc_debug(tbc, "TBC_DIS-req: reason: %u\n", reason);
  17849. + dect_tbc_begin_release(cell, tbc, reason);
  17850. +}
  17851. +
  17852. +static int dect_tbc_establish(struct dect_cell *cell, struct dect_tbc *tbc)
  17853. +{
  17854. + dect_tbc_state_change(tbc, DECT_TBC_ESTABLISHED);
  17855. + if (dect_tbc_establish_cfm(tbc, true) < 0)
  17856. + return -1;
  17857. + return 0;
  17858. +}
  17859. +
  17860. +/**
  17861. + * dect_watchdog_timer - connection watchdog timer
  17862. + *
  17863. + * The watchdog timer is forwarded when an expected event occurs, on expiry
  17864. + * it will release the TBC. The relevant event depends on the TBC's state:
  17865. + *
  17866. + * Until ESTABLISHED state, P_T tails must be sent in every allowed frame.
  17867. + * The timer is forwarded when receiving a P_T tail in an allowed frame.
  17868. + *
  17869. + * In ESTABLISHED state, an RFPI handshake must be received at least
  17870. + * every T201 (5) seconds. The timer is forwarded when receiving an N_T
  17871. + * tail containing a matching RFPI.
  17872. + */
  17873. +static void dect_tbc_watchdog_timer(struct dect_cell *cell, void *data)
  17874. +{
  17875. + struct dect_tbc *tbc = data;
  17876. +
  17877. + tbc_debug(tbc, "watchdog expire\n");
  17878. + if (tbc->state != DECT_TBC_ESTABLISHED) {
  17879. + dect_tbc_establish_cfm(tbc, false);
  17880. + dect_tbc_begin_release(cell, tbc, DECT_REASON_BEARER_SETUP_OR_HANDOVER_FAILED);
  17881. + } else {
  17882. + dect_tbc_release_notify(tbc, DECT_REASON_TIMEOUT_LOST_HANDSHAKE);
  17883. + dect_tbc_begin_release(cell, tbc, DECT_REASON_TIMEOUT_LOST_HANDSHAKE);
  17884. + }
  17885. +}
  17886. +
  17887. +static void dect_tbc_watchdog_reschedule(struct dect_cell *cell,
  17888. + struct dect_tbc *tbc)
  17889. +{
  17890. + u16 timeout;
  17891. +
  17892. + if (tbc->state == DECT_TBC_ESTABLISHED)
  17893. + timeout = DECT_TBC_RFPI_TIMEOUT;
  17894. + else
  17895. + timeout = DECT_MT_FRAME_RATE;
  17896. +
  17897. + tbc_debug(tbc, "watchdog reschedule timeout: %u\n", timeout);
  17898. + dect_bearer_timer_add(cell, &tbc->rxb, &tbc->wd_timer, timeout);
  17899. +}
  17900. +
  17901. +static int dect_tbc_check_attributes(struct dect_cell *cell, struct dect_tbc *tbc,
  17902. + const struct dect_cctrl *cctl)
  17903. +{
  17904. + const struct dect_cluster_handle *clh = cell->handle.clh;
  17905. +
  17906. + tbc_debug(tbc, "RX ATTRIBUTES_T_REQUEST\n");
  17907. + tbc->id.ecn = cctl->attr.ecn;
  17908. + tbc->id.lbn = cctl->attr.lbn;
  17909. + tbc->mcp.service = cctl->attr.service;
  17910. + tbc->mcp.slot = cctl->attr.slot;
  17911. +
  17912. + if (clh->ops->tbc_establish_ind(clh, &cell->handle, &tbc->id,
  17913. + &tbc->mcp, tbc->handover) < 0)
  17914. + return -1;
  17915. + return 0;
  17916. +}
  17917. +
  17918. +/**
  17919. + * dect_tbc_state_process - connection setup and maintenance state proccesing
  17920. + *
  17921. + * Process all messages before ESTABLISHED state, as well as all connection
  17922. + * control messages in ESTABLISHED state.
  17923. + */
  17924. +static int dect_tbc_state_process(struct dect_cell *cell, struct dect_tbc *tbc,
  17925. + const struct dect_tail_msg *tm)
  17926. +{
  17927. + const struct dect_cctrl *cctl = &tm->cctl;
  17928. + u8 framenum;
  17929. +
  17930. + if (tbc->state == DECT_TBC_OTHER_WAIT) {
  17931. + tbc_debug(tbc, "RX in OTHER_WAIT\n");
  17932. + /* Any message except RELEASE switches the bearer to
  17933. + * ESTABLISHED state.
  17934. + */
  17935. + if ((tm->type == DECT_TM_TYPE_BCCTRL ||
  17936. + tm->type == DECT_TM_TYPE_ACCTRL) &&
  17937. + (cctl->fmid != cell->fmid ||
  17938. + cctl->pmid != dect_build_pmid(&tbc->id.pmid) ||
  17939. + cctl->cmd == DECT_CCTRL_RELEASE))
  17940. + goto release;
  17941. +
  17942. + if (dect_tbc_establish(cell, tbc) < 0)
  17943. + goto release;
  17944. + goto out;
  17945. + }
  17946. +
  17947. + /* Before OTHER_WAIT state, M_T tails must be received in every allowed
  17948. + * frame. FPs may send M_T tails in uneven frames, PTs in even frames.
  17949. + * Additionally FPs may transmit responses to BEARER_REQUEST messages in
  17950. + * every frame.
  17951. + */
  17952. + framenum = dect_framenum(cell, DECT_TIMER_RX);
  17953. + if (cell->mode == DECT_MODE_FP) {
  17954. + if ((framenum & 0x1) == 1)
  17955. + return 1;
  17956. + } else {
  17957. + if ((framenum & 0x1) == 0 && tbc->state != DECT_TBC_REQ_SENT)
  17958. + return 1;
  17959. + }
  17960. +
  17961. + if (tm->type != DECT_TM_TYPE_BCCTRL && tm->type != DECT_TM_TYPE_ACCTRL)
  17962. + goto release;
  17963. +
  17964. + switch (cctl->cmd) {
  17965. + case DECT_CCTRL_ATTRIBUTES_T_REQUEST:
  17966. + case DECT_CCTRL_ATTRIBUTES_T_CONFIRM:
  17967. + case DECT_CCTRL_BANDWIDTH_T_REQUEST:
  17968. + case DECT_CCTRL_BANDWIDTH_T_CONFIRM:
  17969. + case DECT_CCTRL_CHANNEL_LIST:
  17970. + break;
  17971. + default:
  17972. + if (cctl->fmid != cell->fmid)
  17973. + goto release;
  17974. + /* fall through */
  17975. + case DECT_CCTRL_RELEASE:
  17976. + if (cctl->pmid != dect_build_pmid(&tbc->id.pmid))
  17977. + goto release;
  17978. + }
  17979. +
  17980. + switch ((int)tbc->state) {
  17981. + case DECT_TBC_NONE:
  17982. + /*
  17983. + * Receiving side, initial request.
  17984. + */
  17985. + dect_tbc_state_change(tbc, DECT_TBC_REQ_RCVD);
  17986. + break;
  17987. +
  17988. + case DECT_TBC_REQ_RCVD:
  17989. + case DECT_TBC_RESPONSE_SENT:
  17990. + /*
  17991. + * Receiving side: waiting for LLME to create MBC. Only "WAIT"
  17992. + * messages are valid in both directions.
  17993. + */
  17994. + tbc_debug(tbc, "RX in REQ_RCVD: %llx\n",
  17995. + (unsigned long long)cctl->cmd);
  17996. +
  17997. + if (tbc->mcp.type == DECT_MAC_CONN_ADVANCED &&
  17998. + cctl->cmd == DECT_CCTRL_ATTRIBUTES_T_REQUEST)
  17999. + dect_tbc_check_attributes(cell, tbc, cctl);
  18000. + else if (cctl->cmd != DECT_CCTRL_WAIT)
  18001. + goto release;
  18002. +
  18003. + if (dect_tbc_send_wait(tbc) < 0)
  18004. + goto release;
  18005. + break;
  18006. +
  18007. + case DECT_TBC_REQ_SENT:
  18008. + case DECT_TBC_WAIT_RCVD:
  18009. + /*
  18010. + * Initiator: request was sent, waiting for confirm. "WAIT"
  18011. + * messages must be responded to with another "WAIT" message.
  18012. + */
  18013. + tbc_debug(tbc, "Reply in REQ_SENT %u\n", tm->type);
  18014. + if (cctl->cmd != DECT_CCTRL_BEARER_CONFIRM) {
  18015. + if (cctl->cmd != DECT_CCTRL_WAIT)
  18016. + goto release;
  18017. + if (dect_tbc_send_wait(tbc) < 0)
  18018. + goto release;
  18019. + dect_tbc_state_change(tbc, DECT_TBC_WAIT_RCVD);
  18020. + } else {
  18021. + tbc_debug(tbc, "Confirmed\n");
  18022. + if (tbc->mcp.type == DECT_MAC_CONN_BASIC) {
  18023. + if (dect_tbc_send_wait(tbc) < 0)
  18024. + goto release;
  18025. + dect_tbc_state_change(tbc, DECT_TBC_OTHER_WAIT);
  18026. + } else {
  18027. + if (dect_tbc_send_attributes_request(tbc) < 0)
  18028. + goto release;
  18029. + dect_tbc_state_change(tbc, DECT_TBC_ATTRIBUTES_SENT);
  18030. + }
  18031. + }
  18032. + break;
  18033. +
  18034. + case DECT_TBC_ATTRIBUTES_SENT:
  18035. + if (cctl->cmd != DECT_CCTRL_ATTRIBUTES_T_CONFIRM) {
  18036. + if (cctl->cmd != DECT_CCTRL_WAIT)
  18037. + goto release;
  18038. + if (dect_tbc_send_wait(tbc) < 0)
  18039. + goto release;
  18040. + } else {
  18041. + if (dect_tbc_send_wait(tbc) < 0)
  18042. + goto release;
  18043. + dect_tbc_state_change(tbc, DECT_TBC_OTHER_WAIT);
  18044. + }
  18045. + break;
  18046. +
  18047. + case DECT_TBC_ESTABLISHED:
  18048. + if (cctl->cmd != DECT_CCTRL_RELEASE)
  18049. + break;
  18050. + /* Immediate release */
  18051. + dect_tbc_release_notify(tbc, DECT_REASON_BEARER_RELEASE);
  18052. + dect_tbc_destroy(cell, tbc);
  18053. + return 0;
  18054. +
  18055. + case DECT_TBC_RELEASING:
  18056. + /*
  18057. + * Unacknowledged release procedure in progress, ignore the
  18058. + * packet unless its a release message, in which case the
  18059. + * bearer can be destroyed immediately (crossed bearer release
  18060. + * procedure).
  18061. + */
  18062. + if (cctl->cmd == DECT_CCTRL_RELEASE)
  18063. + dect_tbc_destroy(cell, tbc);
  18064. +
  18065. + case DECT_TBC_RELEASED:
  18066. + return 0;
  18067. + }
  18068. +
  18069. +out:
  18070. + dect_tbc_watchdog_reschedule(cell, tbc);
  18071. + return 1;
  18072. +
  18073. +release:
  18074. + dect_tbc_establish_cfm(tbc, false);
  18075. + dect_tbc_begin_release(cell, tbc, DECT_REASON_UNKNOWN);
  18076. + return 0;
  18077. +}
  18078. +
  18079. +static void dect_tbc_enc_timer(struct dect_cell *cell, void *data)
  18080. +{
  18081. + struct dect_tbc *tbc = data;
  18082. + enum dect_encctrl_cmds cmd;
  18083. + struct sk_buff *skb;
  18084. +
  18085. + tbc_debug(tbc, "encryption timer: state: %u cnt: %u\n",
  18086. + tbc->enc_state, tbc->enc_msg_cnt);
  18087. +
  18088. + if (++tbc->enc_msg_cnt > 5) {
  18089. + dect_tbc_release_notify(tbc, DECT_REASON_BEARER_RELEASE);
  18090. + return dect_tbc_begin_release(cell, tbc, DECT_REASON_BEARER_RELEASE);
  18091. + }
  18092. +
  18093. + dect_bearer_timer_add(cell, &tbc->txb, &tbc->enc_timer, 2);
  18094. +
  18095. + switch (tbc->enc_state) {
  18096. + case DECT_TBC_ENC_START_REQ_RCVD:
  18097. + tbc_debug(tbc, "TX encryption enabled\n");
  18098. + dect_enable_cipher(tbc->txb.trx, &tbc->txb.chd, tbc->ck);
  18099. + /* fall through */
  18100. + case DECT_TBC_ENC_START_CFM_SENT:
  18101. + tbc->enc_state = DECT_TBC_ENC_START_CFM_SENT;
  18102. + cmd = DECT_ENCCTRL_START_CONFIRM;
  18103. + break;
  18104. + case DECT_TBC_ENC_START_REQ_SENT:
  18105. + cmd = DECT_ENCCTRL_START_REQUEST;
  18106. + break;
  18107. + case DECT_TBC_ENC_STOP_REQ_RCVD:
  18108. + tbc_debug(tbc, "TX encryption disabled\n");
  18109. + dect_disable_cipher(tbc->txb.trx, &tbc->txb.chd);
  18110. + /* fall through */
  18111. + case DECT_TBC_ENC_STOP_CFM_SENT:
  18112. + tbc->enc_state = DECT_TBC_ENC_STOP_CFM_SENT;
  18113. + cmd = DECT_ENCCTRL_STOP_CONFIRM;
  18114. + break;
  18115. + case DECT_TBC_ENC_STOP_REQ_SENT:
  18116. + cmd = DECT_ENCCTRL_STOP_REQUEST;
  18117. + break;
  18118. + default:
  18119. + return;
  18120. + }
  18121. +
  18122. + skb = dect_tbc_build_encctrl(tbc, cmd);
  18123. + if (skb != NULL)
  18124. + dect_tbc_queue_mac_control(tbc, skb);
  18125. +}
  18126. +
  18127. +static int dect_tbc_enc_state_process(struct dect_cell *cell,
  18128. + struct dect_tbc *tbc,
  18129. + const struct dect_tail_msg *tm)
  18130. +{
  18131. + const struct dect_encctrl *ectl = &tm->encctl;
  18132. + struct sk_buff *skb;
  18133. +
  18134. + if (ectl->fmid != cell->fmid ||
  18135. + ectl->pmid != dect_build_pmid(&tbc->id.pmid))
  18136. + return 0;
  18137. +
  18138. + switch (ectl->cmd) {
  18139. + case DECT_ENCCTRL_START_REQUEST:
  18140. + if (tbc->enc_state != DECT_TBC_ENC_DISABLED ||
  18141. + cell->mode != DECT_MODE_FP)
  18142. + break;
  18143. + tbc->enc_state = DECT_TBC_ENC_START_REQ_RCVD;
  18144. + tbc->enc_msg_cnt = 0;
  18145. +
  18146. + dect_bearer_timer_add(cell, &tbc->txb, &tbc->enc_timer, 0);
  18147. + break;
  18148. + case DECT_ENCCTRL_START_CONFIRM:
  18149. + if (tbc->enc_state == DECT_TBC_ENC_START_REQ_SENT) {
  18150. + tbc->enc_state = DECT_TBC_ENC_START_CFM_RCVD;
  18151. + tbc->enc_msg_cnt = 0;
  18152. +
  18153. + dect_timer_del(&tbc->enc_timer);
  18154. + tbc_debug(tbc, "TX encryption enabled\n");
  18155. + dect_enable_cipher(tbc->txb.trx, &tbc->txb.chd, tbc->ck);
  18156. + }
  18157. + if (tbc->enc_state == DECT_TBC_ENC_START_CFM_RCVD) {
  18158. + skb = dect_tbc_build_encctrl(tbc, DECT_ENCCTRL_START_GRANT);
  18159. + if (skb != NULL)
  18160. + dect_tbc_queue_mac_control(tbc, skb);
  18161. + }
  18162. + break;
  18163. + case DECT_ENCCTRL_START_GRANT:
  18164. + if (tbc->enc_state != DECT_TBC_ENC_START_CFM_SENT)
  18165. + break;
  18166. + tbc->enc_state = DECT_TBC_ENC_ENABLED;
  18167. +
  18168. + dect_timer_del(&tbc->enc_timer);
  18169. + tbc_debug(tbc, "RX encryption enabled\n");
  18170. + dect_enable_cipher(tbc->rxb.trx, &tbc->rxb.chd, tbc->ck);
  18171. + dect_tbc_event(tbc, DECT_TBC_CIPHER_ENABLED);
  18172. + break;
  18173. +
  18174. + case DECT_ENCCTRL_STOP_REQUEST:
  18175. + if (cell->mode != DECT_MODE_FP)
  18176. + break;
  18177. +
  18178. + tbc->enc_state = DECT_TBC_ENC_STOP_REQ_RCVD;
  18179. + tbc->enc_msg_cnt = 0;
  18180. +
  18181. + dect_bearer_timer_add(cell, &tbc->txb, &tbc->enc_timer, 0);
  18182. + break;
  18183. + case DECT_ENCCTRL_STOP_CONFIRM:
  18184. + if (tbc->enc_state == DECT_TBC_ENC_STOP_REQ_SENT) {
  18185. + tbc->enc_state = DECT_TBC_ENC_STOP_CFM_RCVD;
  18186. + tbc->enc_msg_cnt = 0;
  18187. +
  18188. + dect_timer_del(&tbc->enc_timer);
  18189. + tbc_debug(tbc, "TX encryption disabled\n");
  18190. + dect_disable_cipher(tbc->txb.trx, &tbc->txb.chd);
  18191. + }
  18192. + if (tbc->enc_state == DECT_TBC_ENC_STOP_CFM_RCVD) {
  18193. + skb = dect_tbc_build_encctrl(tbc, DECT_ENCCTRL_STOP_GRANT);
  18194. + if (skb != NULL)
  18195. + dect_tbc_queue_mac_control(tbc, skb);
  18196. + }
  18197. + break;
  18198. + case DECT_ENCCTRL_STOP_GRANT:
  18199. + if (tbc->enc_state != DECT_TBC_ENC_STOP_CFM_SENT)
  18200. + break;
  18201. + tbc->enc_state = DECT_TBC_CIPHER_DISABLED;
  18202. +
  18203. + dect_timer_del(&tbc->enc_timer);
  18204. + tbc_debug(tbc, "RX encryption disabled\n");
  18205. + dect_disable_cipher(tbc->txb.trx, &tbc->txb.chd);
  18206. + dect_tbc_event(tbc, DECT_TBC_CIPHER_DISABLED);
  18207. + break;
  18208. + default:
  18209. + return 0;
  18210. + }
  18211. + return 1;
  18212. +}
  18213. +
  18214. +static void dect_tbc_queue_cs_data(struct dect_cell *cell, struct dect_tbc *tbc,
  18215. + struct sk_buff *skb,
  18216. + const struct dect_tail_msg *tm)
  18217. +{
  18218. + const struct dect_cluster_handle *clh = cell->handle.clh;
  18219. +
  18220. + skb = skb_clone(skb, GFP_ATOMIC);
  18221. + if (skb == NULL)
  18222. + return;
  18223. + skb_pull(skb, DECT_T_FIELD_OFF);
  18224. + skb_trim(skb, DECT_C_S_SDU_SIZE);
  18225. +
  18226. + DECT_CS_CB(skb)->seq = tm->ctd.seq;
  18227. + clh->ops->tbc_data_ind(clh, &tbc->id, DECT_MC_C_S, skb);
  18228. +}
  18229. +
  18230. +static void dect_tbc_update_handover_state(struct dect_tbc *tbc, bool ok)
  18231. +{
  18232. + const struct dect_cluster_handle *clh = tbc->cell->handle.clh;
  18233. +
  18234. + if (ok) {
  18235. + tbc->handover_tokens += DECT_TBC_HO_TOKENS_OK;
  18236. + if (tbc->handover_tokens > DECT_TBC_HO_TOKENS_MAX)
  18237. + tbc->handover_tokens = DECT_TBC_HO_TOKENS_MAX;
  18238. + } else {
  18239. + tbc->handover_tokens -= DECT_TBC_HO_TOKENS_ERROR;
  18240. + if (tbc->handover_tokens < 0)
  18241. + tbc->handover_tokens = 0;
  18242. + }
  18243. +
  18244. + tbc_debug(tbc, "handover: ok: %u tokens: %d\n", ok, tbc->handover_tokens);
  18245. + if (tbc->handover_tokens == 0)
  18246. + clh->ops->tbc_handover_req(clh, &tbc->id);
  18247. +}
  18248. +
  18249. +static void dect_tbc_report_rssi(struct dect_cell *cell,
  18250. + struct dect_bearer *bearer,
  18251. + u8 slot, u8 rssi)
  18252. +{
  18253. + struct dect_tbc *tbc = bearer->tbc;
  18254. +
  18255. + /* A RSSI report implies an In-Sync error */
  18256. + if (cell->mode == DECT_MODE_PP)
  18257. + dect_tbc_update_handover_state(tbc, false);
  18258. +}
  18259. +
  18260. +#define DECT_CHECKSUM_ALL \
  18261. + (DECT_CHECKSUM_A_CRC_OK | DECT_CHECKSUM_X_CRC_OK | DECT_CHECKSUM_Z_CRC_OK)
  18262. +
  18263. +static bool dect_tbc_checksum_ok(const struct sk_buff *skb)
  18264. +{
  18265. + return (DECT_TRX_CB(skb)->csum & DECT_CHECKSUM_ALL) == DECT_CHECKSUM_ALL;
  18266. +}
  18267. +
  18268. +static void dect_tbc_rcv(struct dect_cell *cell, struct dect_bearer *bearer,
  18269. + struct sk_buff *skb)
  18270. +{
  18271. + const struct dect_cluster_handle *clh = cell->handle.clh;
  18272. + struct dect_tbc *tbc = bearer->tbc;
  18273. + struct dect_tail_msg _tm, *tm = &_tm;
  18274. + bool a_crc_ok, collision;
  18275. + bool q1, q2;
  18276. +
  18277. + dect_raw_rcv(skb);
  18278. +
  18279. + if (cell->mode == DECT_MODE_PP)
  18280. + dect_tbc_update_handover_state(tbc, dect_tbc_checksum_ok(skb));
  18281. +
  18282. + /* Verify A-field checksum. Sucessful reception of the A-field is
  18283. + * indicated by transmitting the Q2 bit in the reverse direction
  18284. + * or the Q1 bit in the direction FP->PP when Q1 is set to 0.
  18285. + */
  18286. + if (DECT_TRX_CB(skb)->csum & DECT_CHECKSUM_A_CRC_OK)
  18287. + tbc->txb.q = DECT_HDR_Q2_FLAG;
  18288. + else
  18289. + goto rcv_b_field;
  18290. +
  18291. + /* Q1 and Q2 bit settings for MAC service IN as per section 10.8.1.3.1 */
  18292. + q1 = skb->data[DECT_HDR_Q1_OFF] & DECT_HDR_Q1_FLAG;
  18293. + q2 = skb->data[DECT_HDR_Q2_OFF] & DECT_HDR_Q2_FLAG;
  18294. +
  18295. + if (cell->mode == DECT_MODE_FP)
  18296. + a_crc_ok = q2;
  18297. + else {
  18298. + if (q2) {
  18299. + a_crc_ok = true;
  18300. + collision = q1;
  18301. + /* ignore collision indications for now as the
  18302. + * transceiver firmware seems to improperly transmit
  18303. + * the Z-Field.
  18304. + */
  18305. + collision = false;
  18306. + } else {
  18307. + a_crc_ok = q1;
  18308. + collision = false;
  18309. + }
  18310. +
  18311. + dect_tbc_update_handover_state(tbc, a_crc_ok && !collision);
  18312. + }
  18313. +
  18314. + if (tbc->cs_tx_ok) {
  18315. + if (a_crc_ok) {
  18316. + tbc_debug(tbc, "ARQ acknowledgement\n");
  18317. + dect_tbc_event(tbc, DECT_TBC_ACK_RECEIVED);
  18318. + } else
  18319. + tbc_debug(tbc, "C-channel data lost\n");
  18320. + }
  18321. +
  18322. + if (dect_parse_tail_msg(tm, skb) < 0)
  18323. + goto err;
  18324. +
  18325. + if (tbc->state != DECT_TBC_ESTABLISHED ||
  18326. + tm->type == DECT_TM_TYPE_BCCTRL ||
  18327. + tm->type == DECT_TM_TYPE_ACCTRL) {
  18328. + if (!dect_tbc_state_process(cell, tbc, tm))
  18329. + goto err;
  18330. + }
  18331. +
  18332. + tbc_debug(tbc, "receive\n");
  18333. +
  18334. + /* Reschedule watchdog on successful RFPI handshake. */
  18335. + if (tm->type == DECT_TM_TYPE_ID && !dect_rfpi_cmp(&tm->idi, &cell->idi))
  18336. + dect_tbc_watchdog_reschedule(cell, tbc);
  18337. +
  18338. + if (tm->type == DECT_TM_TYPE_ENCCTRL) {
  18339. + if (!dect_tbc_enc_state_process(cell, tbc, tm))
  18340. + goto err;
  18341. + }
  18342. +
  18343. + dect_bc_rcv(cell, &tbc->bc, skb, tm);
  18344. +
  18345. + switch (tbc->enc_state) {
  18346. + case DECT_TBC_ENC_START_REQ_SENT:
  18347. + case DECT_TBC_ENC_START_CFM_SENT:
  18348. + goto err;
  18349. + default:
  18350. + break;
  18351. + }
  18352. +
  18353. + if (tbc->state != DECT_TBC_REQ_RCVD &&
  18354. + tbc->state != DECT_TBC_RESPONSE_SENT) {
  18355. + if (tm->type == DECT_TM_TYPE_CT)
  18356. + dect_tbc_queue_cs_data(cell, tbc, skb, tm);
  18357. + }
  18358. +
  18359. +rcv_b_field:
  18360. + switch (dect_parse_b_id(skb)) {
  18361. + case DECT_BI_UTYPE_0:
  18362. + case DECT_BI_UTYPE_1:
  18363. + break;
  18364. + default:
  18365. + goto err;
  18366. + }
  18367. +
  18368. + skb_pull(skb, DECT_A_FIELD_SIZE);
  18369. + skb_trim(skb, dect_pkt_b_field_size(&bearer->chd));
  18370. + clh->ops->tbc_data_ind(clh, &tbc->id, DECT_MC_I_N, skb);
  18371. + return;
  18372. +
  18373. +err:
  18374. + kfree_skb(skb);
  18375. +}
  18376. +
  18377. +static void dect_tbc_data_req(const struct dect_cell_handle *ch,
  18378. + const struct dect_tbc_id *id,
  18379. + enum dect_data_channels chan,
  18380. + struct sk_buff *skb)
  18381. +{
  18382. + struct dect_cell *cell = dect_cell(ch);
  18383. + struct dect_tbc *tbc;
  18384. +
  18385. + tbc = dect_tbc_get_by_tbei(cell, id->tbei);
  18386. + if (tbc == NULL)
  18387. + goto err;
  18388. + tbc_debug(tbc, "TBC_DATA-req: chan: %u len: %u\n", chan, skb->len);
  18389. +
  18390. + switch (chan) {
  18391. + case DECT_MC_C_S:
  18392. + DECT_A_CB(skb)->id = DECT_CS_CB(skb)->seq ? DECT_TI_CT_PKT_1 :
  18393. + DECT_TI_CT_PKT_0;
  18394. + tbc->cs_tx_skb = skb;
  18395. + break;
  18396. + case DECT_MC_I_N:
  18397. + tbc->b_tx_skb = skb;
  18398. + break;
  18399. + default:
  18400. + goto err;
  18401. + }
  18402. + return;
  18403. +
  18404. +err:
  18405. + kfree_skb(skb);
  18406. +}
  18407. +
  18408. +static int dect_tbc_enc_req(const struct dect_cell_handle *ch,
  18409. + const struct dect_tbc_id *id, u64 ck)
  18410. +{
  18411. + struct dect_cell *cell = dect_cell(ch);
  18412. + struct dect_tbc *tbc;
  18413. +
  18414. + tbc = dect_tbc_get_by_tbei(cell, id->tbei);
  18415. + if (tbc == NULL)
  18416. + return -ENOENT;
  18417. +
  18418. + tbc_debug(tbc, "RX/TX encryption enabled: ck: %.16llx\n",
  18419. + (unsigned long long)ck);
  18420. +
  18421. + tbc->ck = ck;
  18422. + dect_enable_cipher(tbc->rxb.trx, &tbc->rxb.chd, tbc->ck);
  18423. + dect_enable_cipher(tbc->txb.trx, &tbc->txb.chd, tbc->ck);
  18424. + return 0;
  18425. +}
  18426. +
  18427. +static int dect_tbc_enc_eks_req(const struct dect_cell_handle *ch,
  18428. + const struct dect_tbc_id *id,
  18429. + enum dect_cipher_states status)
  18430. +{
  18431. + struct dect_cell *cell = dect_cell(ch);
  18432. + struct dect_tbc *tbc;
  18433. + struct sk_buff *skb;
  18434. +
  18435. + tbc = dect_tbc_get_by_tbei(cell, id->tbei);
  18436. + if (tbc == NULL)
  18437. + return -ENOENT;
  18438. +
  18439. + tbc_debug(tbc, "TBC_ENC_EKS-req: status: %u\n", status);
  18440. + if (status == DECT_CIPHER_ENABLED) {
  18441. + skb = dect_tbc_build_encctrl(tbc, DECT_ENCCTRL_START_REQUEST);
  18442. + if (skb != NULL)
  18443. + dect_tbc_queue_mac_control(tbc, skb);
  18444. + tbc->enc_state = DECT_TBC_ENC_START_REQ_SENT;
  18445. +
  18446. + tbc_debug(tbc, "RX encryption enabled\n");
  18447. + dect_enable_cipher(tbc->rxb.trx, &tbc->rxb.chd, tbc->ck);
  18448. + } else {
  18449. + skb = dect_tbc_build_encctrl(tbc, DECT_ENCCTRL_STOP_REQUEST);
  18450. + if (skb != NULL)
  18451. + dect_tbc_queue_mac_control(tbc, skb);
  18452. + tbc->enc_state = DECT_TBC_ENC_STOP_REQ_SENT;
  18453. + }
  18454. +
  18455. + tbc->enc_msg_cnt = 0;
  18456. + dect_bearer_timer_add(cell, &tbc->txb, &tbc->enc_timer, 0);
  18457. + return 0;
  18458. +}
  18459. +
  18460. +static int dect_tbc_enc_key_req(const struct dect_cell_handle *ch,
  18461. + const struct dect_tbc_id *id, u64 ck)
  18462. +{
  18463. + struct dect_cell *cell = dect_cell(ch);
  18464. + struct dect_tbc *tbc;
  18465. +
  18466. + tbc = dect_tbc_get_by_tbei(cell, id->tbei);
  18467. + if (tbc == NULL)
  18468. + return -ENOENT;
  18469. +
  18470. + tbc_debug(tbc, "TBC_ENC_KEY-req: key: %.16llx\n", (unsigned long long)ck);
  18471. + tbc->ck = ck;
  18472. + return 0;
  18473. +}
  18474. +
  18475. +static void dect_tbc_enable(struct dect_cell *cell, struct dect_tbc *tbc)
  18476. +{
  18477. + dect_bearer_enable(&tbc->rxb);
  18478. + dect_bearer_enable(&tbc->txb);
  18479. + dect_bc_init(cell, &tbc->bc);
  18480. +}
  18481. +
  18482. +/*
  18483. + * Activation timer: enable the bearer once the TX channel is accessible,
  18484. + * which is defined by the receivers scanning sequence.
  18485. + */
  18486. +static void dect_tbc_enable_timer(struct dect_cell *cell,
  18487. + struct dect_bearer *bearer)
  18488. +{
  18489. + struct dect_tbc *tbc = bearer->tbc;
  18490. + struct sk_buff *skb, *b_skb;
  18491. + enum dect_cctrl_cmds cmd;
  18492. +
  18493. + tbc_debug(tbc, "TX ACCESS_REQUEST\n");
  18494. + if (tbc->handover)
  18495. + cmd = DECT_CCTRL_BEARER_HANDOVER_REQ;
  18496. + else
  18497. + cmd = DECT_CCTRL_ACCESS_REQ;
  18498. +
  18499. + skb = dect_tbc_build_cctrl(tbc, cmd);
  18500. + if (skb == NULL)
  18501. + return;
  18502. +
  18503. + /* The packet overrides the T-MUX rules. PPs use a special tail
  18504. + * coding for the first transmission. */
  18505. + skb->priority = DECT_MT_HIGH_PRIORITY;
  18506. + if (cell->mode == DECT_MODE_FP)
  18507. + DECT_A_CB(skb)->id = DECT_TI_MT;
  18508. + else
  18509. + DECT_A_CB(skb)->id = DECT_TI_MT_PKT_0;
  18510. +
  18511. + if (tbc->mcp.type == DECT_MAC_CONN_ADVANCED) {
  18512. + b_skb = dect_b_skb_alloc(&tbc->txb.chd);
  18513. + if (b_skb == NULL)
  18514. + goto err1;
  18515. + DECT_B_CB(b_skb)->id = dect_pkt_to_bi(tbc->txb.chd.pkt);
  18516. + tbc->b_tx_skb = b_skb;
  18517. + }
  18518. +
  18519. + dect_tbc_enable(cell, tbc);
  18520. + dect_tbc_queue_mac_control(tbc, skb);
  18521. + dect_tbc_state_change(tbc, DECT_TBC_REQ_SENT);
  18522. +
  18523. + /* Start watchdog */
  18524. + dect_bearer_timer_add(cell, &tbc->rxb, &tbc->wd_timer, 1);
  18525. + return;
  18526. +
  18527. +err1:
  18528. + kfree_skb(skb);
  18529. + //FIXME: indicate error
  18530. +}
  18531. +
  18532. +static const struct dect_bearer_ops dect_tbc_ops = {
  18533. + .state = DECT_TRAFFIC_BEARER,
  18534. + .enable = dect_tbc_enable_timer,
  18535. + .rcv = dect_tbc_rcv,
  18536. + .report_rssi = dect_tbc_report_rssi,
  18537. +};
  18538. +
  18539. +/**
  18540. + * dect_tbc_init - initialise a traffic bearer control instance
  18541. + *
  18542. + * @cell: DECT cell
  18543. + * @id: MBC ID
  18544. + * @rchd: RX channel description
  18545. + * @tchd: TX channel description
  18546. + */
  18547. +static struct dect_tbc *dect_tbc_init(struct dect_cell *cell,
  18548. + const struct dect_tbc_id *id,
  18549. + struct dect_transceiver *rtrx,
  18550. + struct dect_transceiver *ttrx,
  18551. + const struct dect_channel_desc *rchd,
  18552. + const struct dect_channel_desc *tchd)
  18553. +{
  18554. + struct dect_tbc *tbc;
  18555. +
  18556. + tbc = kzalloc(sizeof(*tbc), GFP_ATOMIC);
  18557. + if (tbc == NULL)
  18558. + return NULL;
  18559. +
  18560. + tbc->cell = cell;
  18561. + tbc->id = *id;
  18562. + tbc->handover_tokens = DECT_TBC_HO_TOKENS_INITIAL;
  18563. +
  18564. + INIT_LIST_HEAD(&tbc->bc.list);
  18565. + dect_timer_init(&tbc->wait_timer);
  18566. + dect_timer_setup(&tbc->wd_timer, dect_tbc_watchdog_timer, tbc);
  18567. + dect_timer_setup(&tbc->release_timer, dect_tbc_release_timer, tbc);
  18568. + dect_timer_setup(&tbc->enc_timer, dect_tbc_enc_timer, tbc);
  18569. +
  18570. + dect_bearer_init(cell, &tbc->rxb, &dect_tbc_ops,
  18571. + rtrx, rchd, DECT_BEARER_RX, tbc);
  18572. + dect_bearer_init(cell, &tbc->txb, &dect_tbc_ops,
  18573. + ttrx, tchd, DECT_BEARER_TX, tbc);
  18574. +
  18575. + list_add_tail(&tbc->list, &cell->tbcs);
  18576. + return tbc;
  18577. +}
  18578. +
  18579. +static int dect_tbc_map_params(struct dect_channel_desc *chd,
  18580. + const struct dect_mac_conn_params *mcp)
  18581. +{
  18582. + switch (mcp->service) {
  18583. + case DECT_SERVICE_IN_MIN_DELAY:
  18584. + case DECT_SERVICE_IN_NORMAL_DELAY:
  18585. + case DECT_SERVICE_UNKNOWN:
  18586. + chd->b_fmt = DECT_B_UNPROTECTED;
  18587. + break;
  18588. + default:
  18589. + return -EOPNOTSUPP;
  18590. + }
  18591. +
  18592. + switch (mcp->slot) {
  18593. + case DECT_FULL_SLOT:
  18594. + chd->pkt = DECT_PACKET_P32;
  18595. + break;
  18596. + case DECT_DOUBLE_SLOT:
  18597. + chd->pkt = DECT_PACKET_P80;
  18598. + break;
  18599. + case DECT_LONG_SLOT_640:
  18600. + chd->pkt = DECT_PACKET_P640j;
  18601. + break;
  18602. + case DECT_LONG_SLOT_672:
  18603. + chd->pkt = DECT_PACKET_P672j;
  18604. + break;
  18605. + default:
  18606. + return -EOPNOTSUPP;
  18607. + }
  18608. +
  18609. + return 0;
  18610. +}
  18611. +
  18612. +static int dect_tbc_establish_req(const struct dect_cell_handle *ch,
  18613. + const struct dect_tbc_id *id,
  18614. + const struct dect_mac_conn_params *mcp,
  18615. + bool handover)
  18616. +{
  18617. + struct dect_cell *cell = dect_cell(ch);
  18618. + struct dect_transceiver *ttrx, *rtrx;
  18619. + struct dect_channel_desc tchd, rchd;
  18620. + struct dect_tbc *tbc;
  18621. + u8 rssi;
  18622. + int err;
  18623. +
  18624. + memset(&tchd, 0, sizeof(tchd));
  18625. + err = dect_tbc_map_params(&tchd, mcp);
  18626. + if (err < 0)
  18627. + goto err1;
  18628. +
  18629. + /* Select TDD slot pair and reserve transceiver resources */
  18630. + err = dect_select_channel(cell, &ttrx, &tchd, &rssi, true);
  18631. + if (err < 0)
  18632. + goto err1;
  18633. + dect_channel_reserve(cell, ttrx, &tchd);
  18634. +
  18635. + err = -ENOSPC;
  18636. + dect_tdd_channel_desc(&rchd, &tchd);
  18637. + rtrx = dect_select_transceiver(cell, &rchd);
  18638. + if (rtrx == NULL)
  18639. + goto err2;
  18640. + dect_channel_reserve(cell, rtrx, &rchd);
  18641. +
  18642. + err = -ENOMEM;
  18643. + tbc = dect_tbc_init(cell, id, rtrx, ttrx, &rchd, &tchd);
  18644. + if (tbc == NULL)
  18645. + goto err3;
  18646. + tbc->id.tbei = dect_tbc_alloc_tbei(cell);
  18647. + tbc->mcp = *mcp;
  18648. + tbc->handover = handover;
  18649. +
  18650. + tbc_debug(tbc, "TBC_ESTABLISH-req: handover: %d\n", handover);
  18651. + dect_tx_bearer_schedule(cell, &tbc->txb, rssi);
  18652. + return 0;
  18653. +
  18654. +err3:
  18655. + dect_channel_release(cell, rtrx, &rchd);
  18656. +err2:
  18657. + dect_channel_release(cell, ttrx, &tchd);
  18658. +err1:
  18659. + return err;
  18660. +}
  18661. +
  18662. +/* TBC establishment confirmation from CCF */
  18663. +static int dect_tbc_establish_res(const struct dect_cell_handle *ch,
  18664. + const struct dect_tbc_id *id)
  18665. +{
  18666. + struct dect_cell *cell = dect_cell(ch);
  18667. + struct dect_tbc *tbc;
  18668. + int err;
  18669. +
  18670. + tbc = dect_tbc_get_by_tbei(cell, id->tbei);
  18671. + if (tbc == NULL)
  18672. + return -ENOENT;
  18673. + tbc_debug(tbc, "TBC_ESTABLISH-res\n");
  18674. + WARN_ON(tbc->state != DECT_TBC_REQ_RCVD &&
  18675. + tbc->state != DECT_TBC_RESPONSE_SENT);
  18676. +
  18677. + /* Stop wait timer and send CONFIRM */
  18678. + dect_timer_del(&tbc->wait_timer);
  18679. + if (tbc->mcp.type == DECT_MAC_CONN_BASIC)
  18680. + err = dect_tbc_send_confirm(tbc);
  18681. + else
  18682. + err = dect_tbc_send_attributes_confirm(tbc);
  18683. + if (err < 0)
  18684. + return err;
  18685. +
  18686. + dect_tbc_state_change(tbc, DECT_TBC_OTHER_WAIT);
  18687. + return 0;
  18688. +}
  18689. +
  18690. +static void dect_tbc_wait_timer(struct dect_cell *cell, void *data)
  18691. +{
  18692. + struct dect_tbc *tbc = data;
  18693. + struct sk_buff *skb;
  18694. +
  18695. + tbc_debug(tbc, "wait timer\n");
  18696. + skb = dect_tbc_build_cctrl(tbc, DECT_CCTRL_WAIT);
  18697. + if (skb == NULL)
  18698. + return;
  18699. +
  18700. + /* The first response is permitted in any frame */
  18701. + if (tbc->state == DECT_TBC_REQ_RCVD)
  18702. + skb->priority = DECT_MT_HIGH_PRIORITY;
  18703. + dect_tbc_queue_mac_control(tbc, skb);
  18704. +
  18705. + dect_tbc_state_change(tbc, DECT_TBC_RESPONSE_SENT);
  18706. +}
  18707. +
  18708. +/**
  18709. + * dect_tbc_rcv_request - handle incoming connection setup attempts
  18710. + *
  18711. + *
  18712. + */
  18713. +static void dect_tbc_rcv_request(struct dect_cell *cell,
  18714. + const struct dect_transceiver_slot *ts,
  18715. + const struct dect_tail_msg *tm,
  18716. + struct sk_buff *skb)
  18717. +{
  18718. + const struct dect_cluster_handle *clh = cell->handle.clh;
  18719. + struct dect_transceiver *rtrx, *ttrx;
  18720. + struct dect_channel_desc rchd, tchd;
  18721. + enum dect_b_identifications b_id;
  18722. + enum dect_packet_types pkt;
  18723. + struct sk_buff *b_skb;
  18724. + struct dect_tbc_id id;
  18725. + struct dect_tbc *tbc;
  18726. + bool handover = false;
  18727. +
  18728. + if (tm->cctl.fmid != cell->fmid)
  18729. + goto err1;
  18730. + dect_raw_rcv(skb);
  18731. +
  18732. + switch (tm->cctl.cmd) {
  18733. + case DECT_CCTRL_ACCESS_REQ:
  18734. + break;
  18735. + case DECT_CCTRL_BEARER_HANDOVER_REQ:
  18736. + case DECT_CCTRL_CONNECTION_HANDOVER_REQ:
  18737. + /* Handover can only be initiated by the PP */
  18738. + if (cell->mode == DECT_MODE_FP) {
  18739. + handover = true;
  18740. + break;
  18741. + }
  18742. + default:
  18743. + rx_debug(cell, "unhandled TBC request: %llu\n",
  18744. + (unsigned long long)tm->cctl.cmd);
  18745. + goto err1;
  18746. + }
  18747. +
  18748. + if (tm->type == DECT_TM_TYPE_BCCTRL)
  18749. + pkt = DECT_PACKET_P32;
  18750. + else
  18751. + pkt = dect_bi_to_pkt(dect_parse_b_id(skb));
  18752. +
  18753. + /* Select transceivers for RX/TX and reserve resources */
  18754. + memcpy(&rchd, &ts->chd, sizeof(rchd));
  18755. + rchd.pkt = pkt;
  18756. + rchd.b_fmt = DECT_B_UNPROTECTED;
  18757. + rtrx = dect_select_transceiver(cell, &rchd);
  18758. + if (rtrx == NULL)
  18759. + goto err1;
  18760. + dect_channel_reserve(cell, rtrx, &rchd);
  18761. +
  18762. + dect_tdd_channel_desc(&tchd, &rchd);
  18763. + ttrx = dect_select_transceiver(cell, &tchd);
  18764. + if (ttrx == NULL)
  18765. + goto err2;
  18766. + dect_channel_reserve(cell, ttrx, &tchd);
  18767. +
  18768. + memset(&id, 0, sizeof(id));
  18769. + memcpy(&id.ari, &cell->idi.pari, sizeof(id.ari));
  18770. + dect_parse_pmid(&id.pmid, tm->cctl.pmid);
  18771. + id.lbn = 0xf;
  18772. + id.ecn = 0;
  18773. + id.tbei = dect_tbc_alloc_tbei(cell);
  18774. +
  18775. + /* Initialize TBC */
  18776. + tbc = dect_tbc_init(cell, &id, rtrx, ttrx, &rchd, &tchd);
  18777. + if (tbc == NULL)
  18778. + goto err3;
  18779. +
  18780. + tbc->handover = handover;
  18781. +
  18782. + if (tm->type == DECT_TM_TYPE_BCCTRL) {
  18783. + /* Basic MAC connections only support the I_N_minimal_delay service */
  18784. + tbc->mcp.type = DECT_MAC_CONN_BASIC;
  18785. + tbc->mcp.service = DECT_SERVICE_IN_MIN_DELAY;
  18786. + tbc->mcp.slot = DECT_FULL_SLOT;
  18787. + } else {
  18788. + /* Service is unknown at this time */
  18789. + tbc->mcp.type = DECT_MAC_CONN_ADVANCED;
  18790. + tbc->mcp.service = DECT_SERVICE_UNKNOWN;
  18791. +
  18792. + b_skb = dect_b_skb_alloc(&tchd);
  18793. + if (b_skb == NULL)
  18794. + goto err4;
  18795. + DECT_B_CB(b_skb)->id = b_id;
  18796. + tbc->b_tx_skb = b_skb;
  18797. + }
  18798. +
  18799. + dect_tbc_state_change(tbc, DECT_TBC_REQ_RCVD);
  18800. + tbc_debug(tbc, "RCV ACCESS_REQUEST: pkt: %u\n", pkt);
  18801. +
  18802. + /* Set Q2 bit on first response */
  18803. + tbc->txb.q = DECT_HDR_Q2_FLAG;
  18804. +
  18805. + /* Start the WAIT transmit timer */
  18806. + dect_timer_setup(&tbc->wait_timer, dect_tbc_wait_timer, tbc);
  18807. + dect_bearer_timer_add(cell, &tbc->txb, &tbc->wait_timer, 1);
  18808. +
  18809. + /* Start watchdog timer: until ESTABLISHED state, the remote side
  18810. + * must transmit a M-tail in every allowed frame. */
  18811. + dect_tbc_watchdog_reschedule(cell, tbc);
  18812. + dect_tbc_enable(cell, tbc);
  18813. +
  18814. + if (tbc->mcp.type == DECT_MAC_CONN_BASIC) {
  18815. + if (clh->ops->tbc_establish_ind(clh, &cell->handle, &tbc->id,
  18816. + &tbc->mcp, tbc->handover) < 0)
  18817. + goto err4;
  18818. + } else {
  18819. + if (dect_tbc_send_confirm(tbc) < 0)
  18820. + goto err4;
  18821. + dect_tbc_state_change(tbc, DECT_TBC_RESPONSE_SENT);
  18822. + }
  18823. +
  18824. + kfree_skb(skb);
  18825. + return;
  18826. +
  18827. +err4:
  18828. + dect_tbc_destroy(cell, tbc);
  18829. +err3:
  18830. + dect_channel_release(cell, ttrx, &tchd);
  18831. +err2:
  18832. + dect_channel_release(cell, rtrx, &rchd);
  18833. +err1:
  18834. + kfree_skb(skb);
  18835. +}
  18836. +
  18837. +#if 0
  18838. +/*
  18839. + * Connectionless Bearer Control (CBC)
  18840. + */
  18841. +
  18842. +static void dect_cbc_rcv(struct dect_cell *cell, struct dect_bearer *bearer,
  18843. + struct sk_buff *skb)
  18844. +{
  18845. + struct dect_cbc *cbc = bearer->cbc;
  18846. + struct dect_tail_msg tm;
  18847. +
  18848. + dect_parse_tail_msg(&tm, skb);
  18849. + dect_bc_rcv(cell, &cbc->bc, skb, &tm);
  18850. + kfree_skb(skb);
  18851. +}
  18852. +
  18853. +static const struct dect_bearer_ops dect_cbc_ops = {
  18854. + .state = DECT_CL_BEARER,
  18855. + .rcv = dect_cbc_rcv,
  18856. +};
  18857. +
  18858. +/**
  18859. + * dect_cbc_init - Initialise a connectionless bearer control
  18860. + *
  18861. + * @cell: DECT cell
  18862. + * @chd: channel description
  18863. + */
  18864. +static struct dect_cbc *dect_cbc_init(struct dect_cell *cell,
  18865. + struct dect_channel_desc *chd)
  18866. +{
  18867. + struct dect_bearer *bearer;
  18868. + enum dect_slot_states mode;
  18869. + struct dect_cbc *cbc = NULL;
  18870. +
  18871. + bearer = dect_bearer_init(cell, &dect_cbc_ops, DECT_SIMPLEX_BEARER,
  18872. + NULL, chd, mode, cbc);
  18873. + if (bearer == NULL)
  18874. + return NULL;
  18875. + cbc->dl_bearer = bearer;
  18876. +
  18877. + dect_bc_init(cell, &cbc->bc);
  18878. + return cbc;
  18879. +}
  18880. +#endif
  18881. +
  18882. +/*
  18883. + * Dummy Bearer Control (DBC)
  18884. + */
  18885. +
  18886. +#define dbc_debug(dbc, fmt, args...) \
  18887. + pr_debug("DBC slot %u carrier %u: " fmt, \
  18888. + (dbc)->bearer.chd.slot, (dbc)->bearer.chd.carrier, ## args)
  18889. +
  18890. +static void dect_dbc_rcv(struct dect_cell *cell, struct dect_bearer *bearer,
  18891. + struct sk_buff *skb)
  18892. +{
  18893. + struct dect_dbc *dbc = bearer->dbc;
  18894. + struct dect_tail_msg tm;
  18895. +
  18896. + /* Update A-field receive time stamp (A-field CRC is always correct) */
  18897. + if (dect_framenum(cell, DECT_TIMER_RX) == 0)
  18898. + cell->a_rcv_stamp = jiffies;
  18899. +
  18900. + dect_raw_rcv(skb);
  18901. +
  18902. + if (dect_parse_tail_msg(&tm, skb) < 0)
  18903. + goto err;
  18904. +
  18905. + /* Update Nt receive stamp if PARI matches */
  18906. + if (tm.type == DECT_TM_TYPE_ID && !dect_rfpi_cmp(&tm.idi, &cell->idi))
  18907. + cell->nt_rcv_stamp = jiffies;
  18908. +
  18909. + dect_bc_rcv(cell, &dbc->bc, skb, &tm);
  18910. +err:
  18911. + kfree_skb(skb);
  18912. +}
  18913. +
  18914. +static void dect_dbc_report_rssi(struct dect_cell *cell,
  18915. + struct dect_bearer *bearer,
  18916. + u8 slot, u8 rssi)
  18917. +{
  18918. + dbc_debug(bearer->dbc, "RSSI: selection: %u now: %u\n", bearer->rssi, rssi);
  18919. +}
  18920. +
  18921. +static void dect_dbc_quality_control_timer(struct dect_cell *cell, void *data)
  18922. +{
  18923. + struct dect_dbc *dbc = data;
  18924. + struct dect_bearer *bearer = &dbc->bearer;
  18925. +
  18926. + switch (dbc->qctrl) {
  18927. + case DECT_BEARER_QCTRL_WAIT:
  18928. + dbc_debug(dbc, "quality control: confirm quality\n");
  18929. + dect_set_channel_mode(bearer->trx, &bearer->chd, DECT_SLOT_RX);
  18930. + dect_set_carrier(bearer->trx, bearer->chd.slot, bearer->chd.carrier);
  18931. + dbc->qctrl = DECT_BEARER_QCTRL_CONFIRM;
  18932. + dect_timer_add(cell, &dbc->qctrl_timer, DECT_TIMER_TX,
  18933. + 1, bearer->chd.slot);
  18934. + break;
  18935. + case DECT_BEARER_QCTRL_CONFIRM:
  18936. + dbc_debug(dbc, "quality control: wait\n");
  18937. + dect_set_channel_mode(bearer->trx, &bearer->chd, DECT_SLOT_TX);
  18938. + dect_set_carrier(bearer->trx, bearer->chd.slot, bearer->chd.carrier);
  18939. + dbc->qctrl = DECT_BEARER_QCTRL_WAIT;
  18940. + dect_timer_add(cell, &dbc->qctrl_timer, DECT_TIMER_TX,
  18941. + DECT_BEARER_QCTRL_PERIOD - 1, bearer->chd.slot);
  18942. + break;
  18943. + }
  18944. +}
  18945. +
  18946. +static void dect_dbc_enable(struct dect_cell *cell, struct dect_bearer *bearer)
  18947. +{
  18948. + struct dect_dbc *dbc = bearer->dbc;
  18949. + u8 framenum = dect_framenum(cell, DECT_TIMER_TX);
  18950. + u8 extra;
  18951. +
  18952. + extra = DECT_BEARER_QCTRL_FRAMENUM - framenum;
  18953. + dbc->qctrl = DECT_BEARER_QCTRL_WAIT;
  18954. + dect_timer_add(cell, &dbc->qctrl_timer, DECT_TIMER_TX,
  18955. + DECT_BEARER_QCTRL_PERIOD + extra, bearer->chd.slot);
  18956. +
  18957. + dect_bearer_enable(bearer);
  18958. +}
  18959. +
  18960. +static const struct dect_bearer_ops dect_dbc_ops = {
  18961. + .state = DECT_DUMMY_BEARER,
  18962. + .enable = dect_dbc_enable,
  18963. + .report_rssi = dect_dbc_report_rssi,
  18964. + .rcv = dect_dbc_rcv,
  18965. +};
  18966. +
  18967. +static void dect_dbc_release(struct dect_dbc *dbc)
  18968. +{
  18969. + struct dect_cell *cell = dbc->cell;
  18970. +
  18971. + dect_channel_release(cell, dbc->bearer.trx, &dbc->bearer.chd);
  18972. + dect_bearer_release(cell, &dbc->bearer);
  18973. +
  18974. + dect_timer_del(&dbc->qctrl_timer);
  18975. + dect_bc_release(&dbc->bc);
  18976. + list_del(&dbc->list);
  18977. + kfree(dbc);
  18978. +}
  18979. +
  18980. +/**
  18981. + * dect_dbc_init - initialise dummy bearer control
  18982. + *
  18983. + * @cell: DECT cell
  18984. + * @chd: channel description (PP only)
  18985. + */
  18986. +static struct dect_dbc *dect_dbc_init(struct dect_cell *cell,
  18987. + const struct dect_channel_desc *chd)
  18988. +{
  18989. + struct dect_channel_desc tchd;
  18990. + struct dect_transceiver *trx;
  18991. + enum dect_bearer_modes mode;
  18992. + struct dect_dbc *dbc;
  18993. + u8 uninitialized_var(rssi);
  18994. +
  18995. + /* Transmission is always in direction FP -> PP */
  18996. + if (cell->mode == DECT_MODE_FP) {
  18997. + tchd.pkt = DECT_PACKET_P00;
  18998. + tchd.b_fmt = DECT_B_NONE;
  18999. + if (dect_select_channel(cell, &trx, &tchd, &rssi, false) < 0)
  19000. + goto err1;
  19001. + chd = &tchd;
  19002. +
  19003. + mode = DECT_BEARER_TX;
  19004. + } else {
  19005. + trx = dect_select_transceiver(cell, chd);
  19006. + if (trx == NULL)
  19007. + goto err1;
  19008. + mode = DECT_BEARER_RX;
  19009. + }
  19010. +
  19011. + dect_channel_reserve(cell, trx, chd);
  19012. +
  19013. + dbc = kzalloc(sizeof(*dbc), GFP_ATOMIC);
  19014. + if (dbc == NULL)
  19015. + goto err2;
  19016. + dbc->cell = cell;
  19017. + dect_timer_setup(&dbc->qctrl_timer, dect_dbc_quality_control_timer, dbc);
  19018. + dect_bc_init(cell, &dbc->bc);
  19019. +
  19020. + dect_bearer_init(cell, &dbc->bearer, &dect_dbc_ops, trx, chd, mode, dbc);
  19021. +
  19022. + if (cell->mode == DECT_MODE_FP)
  19023. + dect_tx_bearer_schedule(cell, &dbc->bearer, rssi);
  19024. + else {
  19025. + dect_bearer_enable(&dbc->bearer);
  19026. +
  19027. + cell->a_rcv_stamp = jiffies;
  19028. + cell->nt_rcv_stamp = jiffies;
  19029. + }
  19030. +
  19031. + list_add_tail(&dbc->list, &cell->dbcs);
  19032. + return dbc;
  19033. +
  19034. +err2:
  19035. + dect_channel_release(cell, trx, chd);
  19036. +err1:
  19037. + return NULL;
  19038. +}
  19039. +
  19040. +/*
  19041. + * Monitor Bearer
  19042. + */
  19043. +
  19044. +static void dect_dmb_release(struct dect_cell *cell, struct dect_dmb *dmb)
  19045. +{
  19046. + cell->tbc_last_chd = dmb->rxb2.chd;
  19047. +
  19048. + dect_timer_del(&dmb->wd_timer);
  19049. +
  19050. + dect_transceiver_release(&cell->trg, dmb->rxb1.trx, &dmb->rxb1.chd);
  19051. + dect_bearer_release(dmb->cell, &dmb->rxb1);
  19052. +
  19053. + dect_transceiver_release(&cell->trg, dmb->rxb2.trx, &dmb->rxb2.chd);
  19054. + dect_bearer_release(dmb->cell, &dmb->rxb2);
  19055. +
  19056. + dect_bc_release(&dmb->bc);
  19057. + list_del(&dmb->list);
  19058. + kfree(dmb);
  19059. +}
  19060. +
  19061. +static void dect_dmb_watchdog_timer(struct dect_cell *cell, void *data)
  19062. +{
  19063. + dect_dmb_release(cell, data);
  19064. +}
  19065. +
  19066. +static void dect_dmb_watchdog_reschedule(struct dect_cell *cell,
  19067. + struct dect_dmb *dmb)
  19068. +{
  19069. + dect_bearer_timer_add(cell, &dmb->rxb1, &dmb->wd_timer,
  19070. + DECT_TBC_RFPI_TIMEOUT);
  19071. +}
  19072. +
  19073. +static void dect_dmb_rcv(struct dect_cell *cell, struct dect_bearer *bearer,
  19074. + struct sk_buff *skb)
  19075. +{
  19076. + struct dect_dmb *dmb = bearer->dmb;
  19077. + struct dect_tail_msg tm;
  19078. +
  19079. + dect_raw_rcv(skb);
  19080. +
  19081. + if (dect_parse_tail_msg(&tm, skb) < 0)
  19082. + goto err;
  19083. +
  19084. + /* Reschedule watchdog on successful RFPI handshake. */
  19085. + if (tm.type == DECT_TM_TYPE_ID && !dect_rfpi_cmp(&tm.idi, &cell->idi))
  19086. + dect_dmb_watchdog_reschedule(cell, dmb);
  19087. +
  19088. + dect_bc_rcv(cell, &dmb->bc, skb, &tm);
  19089. +
  19090. + switch (tm.type) {
  19091. + case DECT_TM_TYPE_BCCTRL:
  19092. + case DECT_TM_TYPE_ACCTRL:
  19093. + if (tm.cctl.cmd == DECT_CCTRL_RELEASE)
  19094. + return dect_dmb_release(cell, dmb);
  19095. + break;
  19096. + default:
  19097. + break;
  19098. + }
  19099. +err:
  19100. + kfree_skb(skb);
  19101. +}
  19102. +
  19103. +static const struct dect_bearer_ops dect_dmb_ops = {
  19104. + .state = DECT_MONITOR_BEARER,
  19105. + .rcv = dect_dmb_rcv,
  19106. +};
  19107. +
  19108. +static struct dect_dmb *dect_dmb_init(struct dect_cell *cell,
  19109. + struct dect_transceiver *trx1,
  19110. + struct dect_transceiver *trx2,
  19111. + const struct dect_channel_desc *chd1,
  19112. + const struct dect_channel_desc *chd2)
  19113. +{
  19114. + struct dect_dmb *dmb;
  19115. +
  19116. + dmb = kzalloc(sizeof(*dmb), GFP_ATOMIC);
  19117. + if (dmb == NULL)
  19118. + return NULL;
  19119. + dmb->cell = cell;
  19120. +
  19121. + dect_timer_setup(&dmb->wd_timer, dect_dmb_watchdog_timer, dmb);
  19122. + dect_bearer_init(cell, &dmb->rxb1, &dect_dmb_ops,
  19123. + trx1, chd1, DECT_BEARER_RX, dmb);
  19124. + dect_bearer_init(cell, &dmb->rxb2, &dect_dmb_ops,
  19125. + trx2, chd2, DECT_BEARER_RX, dmb);
  19126. + dect_bc_init(cell, &dmb->bc);
  19127. +
  19128. + list_add_tail(&dmb->list, &cell->dmbs);
  19129. + return dmb;
  19130. +}
  19131. +
  19132. +static void dect_dmb_rcv_request(struct dect_cell *cell,
  19133. + const struct dect_transceiver_slot *ts,
  19134. + const struct dect_tail_msg *tm,
  19135. + struct sk_buff *skb)
  19136. +{
  19137. + struct dect_transceiver *trx1, *trx2;
  19138. + struct dect_channel_desc chd1, chd2;
  19139. + struct dect_dmb *dmb;
  19140. +
  19141. + if (tm->cctl.fmid != cell->fmid)
  19142. + goto err1;
  19143. + dect_raw_rcv(skb);
  19144. +
  19145. + switch (tm->cctl.cmd) {
  19146. + case DECT_CCTRL_ACCESS_REQ:
  19147. + case DECT_CCTRL_BEARER_HANDOVER_REQ:
  19148. + case DECT_CCTRL_CONNECTION_HANDOVER_REQ:
  19149. + break;
  19150. + default:
  19151. + rx_debug(cell, "unhandled DMB request: %llu\n",
  19152. + (unsigned long long)tm->cctl.cmd);
  19153. + goto err1;
  19154. + }
  19155. +
  19156. + rx_debug(cell, "DMB: RCV ACCESS_REQUEST\n");
  19157. +
  19158. + /* Select transceivers for RX/TX and reserve resources */
  19159. + memcpy(&chd1, &ts->chd, sizeof(chd1));
  19160. + chd1.pkt = DECT_PACKET_P32;
  19161. + chd1.b_fmt = DECT_B_UNPROTECTED;
  19162. + trx1 = dect_select_transceiver(cell, &chd1);
  19163. + if (trx1 == NULL)
  19164. + goto err1;
  19165. + dect_transceiver_reserve(&cell->trg, trx1, &chd1);
  19166. +
  19167. + dect_tdd_channel_desc(&chd2, &chd1);
  19168. + trx2 = dect_select_transceiver(cell, &chd2);
  19169. + if (trx2 == NULL)
  19170. + goto err2;
  19171. + dect_transceiver_reserve(&cell->trg, trx2, &chd2);
  19172. +
  19173. + dmb = dect_dmb_init(cell, trx1, trx2, &chd1, &chd2);
  19174. + if (dmb == NULL)
  19175. + goto err3;
  19176. +
  19177. + dect_bearer_enable(&dmb->rxb1);
  19178. + dect_bearer_enable(&dmb->rxb2);
  19179. +
  19180. + dect_bearer_timer_add(cell, &dmb->rxb1, &dmb->wd_timer,
  19181. + DECT_TBC_RFPI_TIMEOUT);
  19182. +
  19183. + kfree_skb(skb);
  19184. + return;
  19185. +
  19186. +err3:
  19187. + dect_transceiver_release(&cell->trg, trx2, &chd2);
  19188. +err2:
  19189. + dect_transceiver_release(&cell->trg, trx1, &chd1);
  19190. +err1:
  19191. + kfree_skb(skb);
  19192. +}
  19193. +
  19194. +/*
  19195. + * Idle Receiver Control
  19196. + */
  19197. +
  19198. +static void dect_initiate_scan(struct dect_transceiver *trx,
  19199. + const struct dect_ari *ari,
  19200. + const struct dect_ari *ari_mask,
  19201. + void (*notify)(struct dect_cell *,
  19202. + struct dect_transceiver *,
  19203. + enum dect_scan_status))
  19204. +{
  19205. + struct dect_irc *irc = trx->irc;
  19206. +
  19207. + if (ari != NULL) {
  19208. + memcpy(&irc->ari, ari, sizeof(irc->ari));
  19209. + if (ari_mask != NULL)
  19210. + memcpy(&irc->ari_mask, ari_mask, sizeof(irc->ari_mask));
  19211. + else
  19212. + memset(&irc->ari_mask, 0xff, sizeof(irc->ari_mask));
  19213. + }
  19214. +
  19215. + memset(&irc->si, 0, sizeof(irc->si));
  19216. + irc->notify = notify;
  19217. +
  19218. + dect_transceiver_enable(trx);
  19219. + dect_set_channel_mode(trx, &trx->slots[DECT_SCAN_SLOT].chd, DECT_SLOT_SCANNING);
  19220. +}
  19221. +
  19222. +static void dect_restart_scan(struct dect_cell *cell,
  19223. + struct dect_transceiver *trx)
  19224. +{
  19225. + struct dect_irc *irc = trx->irc;
  19226. +
  19227. + dect_transceiver_unlock(trx);
  19228. + memset(&irc->si, 0, sizeof(irc->si));
  19229. + dect_set_channel_mode(trx, &trx->slots[DECT_SCAN_SLOT].chd, DECT_SLOT_SCANNING);
  19230. +}
  19231. +
  19232. +/* This function controls the transceiver while scanning. It collects the
  19233. + * information requested in struct dect_scan_ctrl and invokes the completion
  19234. + * handler once all information is available.
  19235. + */
  19236. +void dect_mac_irc_rcv(struct dect_transceiver *trx, struct sk_buff *skb)
  19237. +{
  19238. + struct dect_cell *cell = trx->cell;
  19239. + struct dect_irc *irc = trx->irc;
  19240. + struct dect_tail_msg tm;
  19241. +
  19242. + if (dect_parse_tail_msg(&tm, skb) < 0)
  19243. + goto err;
  19244. +
  19245. + switch (trx->state) {
  19246. + case DECT_TRANSCEIVER_UNLOCKED:
  19247. + if (tm.type != DECT_TM_TYPE_ID)
  19248. + break;
  19249. + if (dect_ari_masked_cmp(&tm.idi.pari, &irc->ari, &irc->ari_mask))
  19250. + break;
  19251. + memcpy(&irc->idi, &tm.idi, sizeof(irc->idi));
  19252. +
  19253. + irc->timeout = 16 * DECT_FRAMES_PER_MULTIFRAME;
  19254. + irc->rssi = dect_average_rssi(0, DECT_TRX_CB(skb)->rssi);
  19255. + dect_transceiver_confirm(trx);
  19256. + break;
  19257. + case DECT_TRANSCEIVER_LOCK_PENDING:
  19258. + irc->rssi = dect_average_rssi(irc->rssi, DECT_TRX_CB(skb)->rssi);
  19259. + if (dect_parse_tail(skb) == DECT_TI_QT) {
  19260. + dect_bc_update_si(&irc->si, &tm);
  19261. + if (dect_bc_si_cycle_complete(&irc->idi, &irc->si) &&
  19262. + tm.type == DECT_TM_TYPE_MFN)
  19263. + irc->notify(cell, trx, DECT_SCAN_COMPLETE);
  19264. + }
  19265. + break;
  19266. + default:
  19267. + break;
  19268. + }
  19269. +err:
  19270. + kfree_skb(skb);
  19271. +}
  19272. +
  19273. +void dect_mac_irc_tick(struct dect_transceiver *trx)
  19274. +{
  19275. + struct dect_cell *cell = trx->cell;
  19276. + struct dect_irc *irc = trx->irc;
  19277. +
  19278. + switch (trx->state) {
  19279. + case DECT_TRANSCEIVER_UNLOCKED:
  19280. + /* maintain scan until clock is running */
  19281. + irc->rx_scn = dect_next_carrier(0x3ff, irc->rx_scn);
  19282. + dect_set_carrier(trx, DECT_SCAN_SLOT, irc->rx_scn);
  19283. + break;
  19284. + case DECT_TRANSCEIVER_LOCK_PENDING:
  19285. + irc->si.ssi.pscn = dect_next_carrier(0x3ff, irc->si.ssi.pscn);
  19286. + if (--irc->timeout == 0)
  19287. + irc->notify(cell, trx, DECT_SCAN_TIMEOUT);
  19288. + break;
  19289. + default:
  19290. + break;
  19291. + }
  19292. +}
  19293. +
  19294. +static void dect_scan_bearer_rcv(struct dect_cell *cell,
  19295. + struct dect_bearer *bearer,
  19296. + struct sk_buff *skb)
  19297. +{
  19298. + struct dect_transceiver *trx = bearer->trx;
  19299. + struct dect_transceiver_slot *ts;
  19300. + enum dect_tail_identifications ti;
  19301. + struct dect_tail_msg tm;
  19302. + bool monitor = false;
  19303. +
  19304. + ti = dect_parse_tail(skb);
  19305. + /* A PP uses a special encoding for the first transmission */
  19306. + if (cell->mode == DECT_MODE_FP && ti != DECT_TI_MT_PKT_0)
  19307. + goto out;
  19308. + if (cell->mode == DECT_MODE_PP) {
  19309. + if (cell->flags & DECT_CELL_MONITOR && ti == DECT_TI_MT_PKT_0)
  19310. + monitor = true;
  19311. + else if (ti != DECT_TI_MT)
  19312. + goto out;
  19313. + }
  19314. +
  19315. + if (dect_parse_tail_msg(&tm, skb) < 0)
  19316. + goto out;
  19317. +
  19318. + ts = &trx->slots[DECT_TRX_CB(skb)->slot];
  19319. + switch (tm.type) {
  19320. + case DECT_TM_TYPE_BCCTRL:
  19321. + case DECT_TM_TYPE_ACCTRL:
  19322. + if (monitor)
  19323. + return dect_dmb_rcv_request(cell, ts, &tm, skb);
  19324. + else
  19325. + return dect_tbc_rcv_request(cell, ts, &tm, skb);
  19326. + default:
  19327. + break;
  19328. + }
  19329. +out:
  19330. + kfree_skb(skb);
  19331. +}
  19332. +
  19333. +static void dect_scan_bearer_report_rssi(struct dect_cell *cell,
  19334. + struct dect_bearer *bearer,
  19335. + u8 slot, u8 rssi)
  19336. +{
  19337. + if (cell->chl == NULL)
  19338. + return;
  19339. + dect_chl_update(cell, cell->chl, &bearer->trx->slots[slot].chd, rssi);
  19340. +}
  19341. +
  19342. +static const struct dect_bearer_ops dect_scan_ops = {
  19343. + .report_rssi = dect_scan_bearer_report_rssi,
  19344. + .rcv = dect_scan_bearer_rcv,
  19345. +};
  19346. +
  19347. +static void dect_scan_channel_desc(struct dect_channel_desc *chd)
  19348. +{
  19349. + memset(chd, 0, sizeof(*chd));
  19350. + chd->pkt = DECT_PACKET_P32;
  19351. + chd->b_fmt = DECT_B_UNPROTECTED;
  19352. +}
  19353. +
  19354. +static void dect_chl_scan_channel_desc(struct dect_channel_desc *chd,
  19355. + const struct dect_channel_list *chl)
  19356. +{
  19357. + memset(chd, 0, sizeof(*chd));
  19358. + chd->pkt = chl->pkt;
  19359. + if (chl->pkt == DECT_PACKET_P00)
  19360. + chd->b_fmt = DECT_B_NONE;
  19361. + else
  19362. + chd->b_fmt = DECT_B_UNPROTECTED;
  19363. +}
  19364. +
  19365. +static void dect_scan_bearer_enable(struct dect_transceiver *trx,
  19366. + const struct dect_channel_desc *chd)
  19367. +{
  19368. + trx->slots[chd->slot].bearer = &trx->irc->scan_bearer;
  19369. + dect_set_channel_mode(trx, chd, DECT_SLOT_SCANNING);
  19370. +}
  19371. +
  19372. +static void dect_scan_bearer_disable(struct dect_transceiver *trx,
  19373. + const struct dect_channel_desc *chd)
  19374. +{
  19375. + dect_set_channel_mode(trx, chd, DECT_SLOT_IDLE);
  19376. + trx->slots[chd->slot].bearer = NULL;
  19377. +}
  19378. +
  19379. +static void dect_irc_tx_frame_timer(struct dect_cell *cell, void *data)
  19380. +{
  19381. + struct dect_irc *irc = data;
  19382. + struct dect_transceiver *trx = irc->trx;
  19383. + struct dect_channel_desc chd;
  19384. + u8 end;
  19385. +
  19386. + irc->tx_scn = dect_next_carrier(cell->si.ssi.rfcars, irc->tx_scn);
  19387. +
  19388. + /* Begin a pending channel list update:
  19389. + *
  19390. + * The IRC of the first transceiver that reaches a new frame queues the
  19391. + * channel list. All IRCs then switch the idle normal transmit slots
  19392. + * to scanning mode and switch all scanning slots to the lists physical
  19393. + * channel type. The actual update will begin once the receive side
  19394. + * reaches the same frame.
  19395. + */
  19396. + if (cell->chl == NULL && cell->chl_next == NULL)
  19397. + cell->chl_next = dect_chl_get_pending(cell);
  19398. +
  19399. + if (cell->chl_next != NULL) {
  19400. + dect_chl_scan_channel_desc(&chd, cell->chl_next);
  19401. + dect_foreach_receive_slot(chd.slot, end, cell) {
  19402. + if (trx->slots[chd.slot].state != DECT_SLOT_IDLE &&
  19403. + trx->slots[chd.slot].state != DECT_SLOT_SCANNING)
  19404. + continue;
  19405. + if (!dect_transceiver_channel_available(trx, &chd))
  19406. + continue;
  19407. +
  19408. + dect_scan_bearer_enable(trx, &chd);
  19409. + }
  19410. + dect_foreach_transmit_slot(chd.slot, end, cell) {
  19411. + if (trx->slots[chd.slot].state != DECT_SLOT_IDLE)
  19412. + continue;
  19413. + if (!dect_transceiver_channel_available(trx, &chd))
  19414. + continue;
  19415. + dect_scan_bearer_enable(trx, &chd);
  19416. + }
  19417. + } else if (cell->chl == NULL) {
  19418. + /* Switch back primary, secondary and tertiary scan to proper
  19419. + * packet format and disable scan on remaining transceivers
  19420. + * after the channel list update is complete.
  19421. + */
  19422. + dect_scan_channel_desc(&chd);
  19423. + dect_foreach_receive_slot(chd.slot, end, cell) {
  19424. + if (trx->slots[chd.slot].state != DECT_SLOT_SCANNING)
  19425. + continue;
  19426. +
  19427. + if (trx->index < 3)
  19428. + dect_scan_bearer_enable(trx, &chd);
  19429. + else
  19430. + dect_scan_bearer_disable(trx, &chd);
  19431. + }
  19432. +
  19433. + /* In monitor mode, transmit slots keep scanning for FP setup
  19434. + * attempts.
  19435. + */
  19436. + if (!(cell->flags & DECT_CELL_MONITOR)) {
  19437. + dect_foreach_transmit_slot(chd.slot, end, cell) {
  19438. + if (trx->slots[chd.slot].state != DECT_SLOT_SCANNING)
  19439. + continue;
  19440. + dect_scan_bearer_disable(trx, &chd);
  19441. + }
  19442. + }
  19443. + }
  19444. +
  19445. + dect_timer_add(cell, &irc->tx_frame_timer, DECT_TIMER_TX, 1, 0);
  19446. +}
  19447. +
  19448. +static void dect_irc_rx_frame_timer(struct dect_cell *cell, void *data)
  19449. +{
  19450. + struct dect_irc *irc = data;
  19451. +
  19452. + /* Update the list status at the end of a frame in case of an
  19453. + * active update or activate an update before a new frame begins.
  19454. + */
  19455. + if (cell->chl != NULL)
  19456. + dect_chl_update_carrier(cell, irc->rx_scn);
  19457. + else if (cell->chl_next != NULL) {
  19458. + cell->chl = cell->chl_next;
  19459. + cell->chl_next = NULL;
  19460. + chl_debug(cell, cell->chl, "begin update\n");
  19461. + }
  19462. +
  19463. + irc->rx_scn = dect_next_carrier(cell->si.ssi.rfcars, irc->rx_scn);
  19464. + dect_timer_add(cell, &irc->rx_frame_timer, DECT_TIMER_RX, 1, 23);
  19465. +}
  19466. +
  19467. +/* Primary, secondary and tertiary scan: the secondary scan lags behind the
  19468. + * primary scan by 6 TDMA frames, the tertiary scan by 3 TDMA frames.
  19469. + *
  19470. + * Additional transceivers don't scan for setup attempts, however they each
  19471. + * cover a different carrier in order to speed up channel list construction.
  19472. + */
  19473. +static const u8 scn_off_tbl[10] = {
  19474. + [0] = 0,
  19475. + [1] = 6,
  19476. + [2] = 3,
  19477. + [3] = 8,
  19478. + [4] = 1,
  19479. + [5] = 4,
  19480. + [6] = 9,
  19481. + [7] = 2,
  19482. + [8] = 5,
  19483. + [9] = 7,
  19484. +};
  19485. +
  19486. +static void dect_irc_enable(struct dect_cell *cell, struct dect_irc *irc)
  19487. +{
  19488. + struct dect_transceiver *trx = irc->trx;
  19489. + struct dect_channel_desc chd;
  19490. + u8 end, scn_off, scn;
  19491. +
  19492. + if (trx->index >= 10)
  19493. + return;
  19494. +
  19495. + scn_off = scn_off_tbl[trx->index];
  19496. + scn = dect_carrier_sub(cell->si.ssi.rfcars, cell->si.ssi.pscn, scn_off);
  19497. + irc->rx_scn = scn;
  19498. + irc->tx_scn = scn;
  19499. +
  19500. + if (trx->index < 3) {
  19501. + /* Set all idle slots to scanning */
  19502. + dect_scan_channel_desc(&chd);
  19503. + dect_foreach_receive_slot(chd.slot, end, cell) {
  19504. + if (trx->slots[chd.slot].state != DECT_SLOT_IDLE)
  19505. + continue;
  19506. + if (!dect_transceiver_channel_available(trx, &chd))
  19507. + continue;
  19508. + dect_scan_bearer_enable(trx, &chd);
  19509. + }
  19510. +
  19511. + if (cell->flags & DECT_CELL_MONITOR) {
  19512. + dect_foreach_transmit_slot(chd.slot, end, cell) {
  19513. + if (!dect_transceiver_channel_available(trx, &chd))
  19514. + continue;
  19515. + dect_scan_bearer_enable(trx, &chd);
  19516. + }
  19517. + }
  19518. + }
  19519. +
  19520. + /* Start frame timers */
  19521. + dect_timer_add(cell, &irc->tx_frame_timer, DECT_TIMER_TX, 1, 0);
  19522. + dect_timer_add(cell, &irc->rx_frame_timer, DECT_TIMER_RX, 0, 23);
  19523. +}
  19524. +
  19525. +static void dect_irc_disable(struct dect_cell *cell, struct dect_irc *irc)
  19526. +{
  19527. + struct dect_transceiver *trx = irc->trx;
  19528. + u8 slot;
  19529. +
  19530. + dect_timer_del(&irc->rx_frame_timer);
  19531. + dect_timer_del(&irc->tx_frame_timer);
  19532. +
  19533. + dect_foreach_slot(slot) {
  19534. + if (trx->slots[slot].state != DECT_SLOT_SCANNING)
  19535. + continue;
  19536. + dect_scan_bearer_disable(trx, &trx->slots[slot].chd);
  19537. + }
  19538. +}
  19539. +
  19540. +static struct dect_irc *dect_irc_init(struct dect_cell *cell,
  19541. + struct dect_transceiver *trx)
  19542. +{
  19543. + struct dect_irc *irc;
  19544. +
  19545. + irc = kzalloc(sizeof(*irc), GFP_KERNEL);
  19546. + if (irc == NULL)
  19547. + return NULL;
  19548. +
  19549. + irc->cell = cell;
  19550. + dect_timer_setup(&irc->rx_frame_timer, dect_irc_rx_frame_timer, irc);
  19551. + dect_timer_setup(&irc->tx_frame_timer, dect_irc_tx_frame_timer, irc);
  19552. + irc->scan_bearer.ops = &dect_scan_ops;
  19553. + irc->scan_bearer.irc = irc;
  19554. + irc->scan_bearer.trx = trx;
  19555. + irc->scan_bearer.mode = DECT_BEARER_RX;
  19556. + irc->scan_bearer.state = DECT_BEARER_ENABLED;
  19557. + irc->trx = trx;
  19558. + trx->irc = irc;
  19559. + return irc;
  19560. +}
  19561. +
  19562. +static void dect_lock_fp(struct dect_cell *cell, struct dect_transceiver *trx,
  19563. + enum dect_scan_status status)
  19564. +{
  19565. + const struct dect_cluster_handle *clh = cell->handle.clh;
  19566. + struct dect_irc *irc = trx->irc;
  19567. + struct dect_si *si = &irc->si;
  19568. + struct dect_channel_desc chd;
  19569. + struct dect_dbc *dbc;
  19570. +
  19571. + switch (status) {
  19572. + case DECT_SCAN_FAIL:
  19573. + case DECT_SCAN_TIMEOUT:
  19574. + return dect_restart_scan(cell, trx);
  19575. + case DECT_SCAN_COMPLETE:
  19576. + break;
  19577. + }
  19578. +
  19579. + dect_set_channel_mode(trx, &trx->slots[DECT_SCAN_SLOT].chd, DECT_SLOT_IDLE);
  19580. +
  19581. + chd.slot = si->ssi.sn + (si->ssi.nr ? DECT_HALF_FRAME_SIZE : 0);
  19582. + chd.carrier = si->ssi.cn;
  19583. + chd.pkt = DECT_PACKET_P00;
  19584. + chd.b_fmt = DECT_B_NONE;
  19585. +
  19586. + if (!dect_transceiver_channel_available(trx, &chd))
  19587. + return dect_restart_scan(cell, trx);
  19588. +
  19589. + if (cell->mode != DECT_MODE_FP) {
  19590. + memcpy(&cell->idi, &irc->idi, sizeof(cell->idi));
  19591. + cell->fmid = dect_build_fmid(&cell->idi);
  19592. + memcpy(&cell->si, si, sizeof(cell->si));
  19593. +
  19594. + /* Q-channel information is broadcast in frame 8 */
  19595. + dect_timer_synchronize_framenum(cell, DECT_Q_CHANNEL_FRAME);
  19596. + dect_timer_synchronize_mfn(cell, si->mfn.num);
  19597. +
  19598. + /* Lock framing based on slot position and create DBC */
  19599. + dect_transceiver_lock(trx, chd.slot);
  19600. + dect_dbc_init(cell, &chd);
  19601. +
  19602. + clh->ops->mac_info_ind(clh, &cell->idi, &cell->si);
  19603. + } else {
  19604. + /* secondary transceiver */
  19605. + dbc = dect_dbc_get(cell);
  19606. + if (!(cell->flags & DECT_CELL_SLAVE) &&
  19607. + (dbc == NULL ||
  19608. + dbc->bearer.chd.slot != chd.slot ||
  19609. + dbc->bearer.chd.carrier != chd.carrier))
  19610. + return dect_restart_scan(cell, trx);
  19611. +
  19612. + dect_transceiver_lock(trx, chd.slot);
  19613. +
  19614. + /* Lock to the primary dummy bearer to keep the radio synchronized */
  19615. + /* FIXME: do this cleanly */
  19616. + dect_channel_reserve(cell, trx, &chd);
  19617. + dect_set_channel_mode(trx, &chd, DECT_SLOT_RX);
  19618. + dect_set_flags(trx, chd.slot, DECT_SLOT_SYNC);
  19619. + dect_set_carrier(trx, chd.slot, chd.carrier);
  19620. + }
  19621. +
  19622. + /* Enable IRC */
  19623. + dect_irc_enable(cell, irc);
  19624. +}
  19625. +
  19626. +static void dect_attempt_lock(struct dect_cell *cell,
  19627. + struct dect_transceiver *trx)
  19628. +{
  19629. + dect_initiate_scan(trx, &cell->idi.pari, NULL, dect_lock_fp);
  19630. +}
  19631. +
  19632. +/*
  19633. + * Transmission: A- and B-Field MUXes
  19634. + */
  19635. +
  19636. +static struct sk_buff *dect_u_mux(struct dect_cell *cell,
  19637. + struct dect_bearer *bearer)
  19638. +{
  19639. + struct sk_buff *skb = NULL;
  19640. + struct dect_tbc *tbc;
  19641. +
  19642. + if (bearer->ops->state == DECT_TRAFFIC_BEARER) {
  19643. + tbc = bearer->tbc;
  19644. + skb = tbc->b_tx_skb;
  19645. + tbc->b_tx_skb = NULL;
  19646. + }
  19647. +
  19648. + if (skb == NULL) {
  19649. + skb = dect_b_skb_alloc(&bearer->chd);
  19650. + if (skb == NULL)
  19651. + return NULL;
  19652. + DECT_B_CB(skb)->id = DECT_BI_UTYPE_0;
  19653. + }
  19654. +
  19655. + return skb;
  19656. +}
  19657. +
  19658. +static struct sk_buff *dect_eu_mux(struct dect_cell *cell,
  19659. + struct dect_bearer *bearer)
  19660. +{
  19661. + return dect_u_mux(cell, bearer);
  19662. +}
  19663. +
  19664. +static struct sk_buff *dect_b_map(struct dect_cell *cell,
  19665. + struct dect_bearer *bearer)
  19666. +{
  19667. + return dect_eu_mux(cell, bearer);
  19668. +}
  19669. +
  19670. +#define tmux_debug(cell, fmt, args...) \
  19671. + tx_debug(cell, "%s T-MUX: " fmt, \
  19672. + cell->mode == DECT_MODE_FP ? "FT" : "PT", ## args)
  19673. +
  19674. +/**
  19675. + * dect_pt_t_mux - DECT T-MUX for PT transmissions
  19676. + *
  19677. + * @cell: DECT cell
  19678. + * @bearer: MAC bearer
  19679. + *
  19680. + * The PT T-MUX sequence is used by PTs for all traffic bearers in connection
  19681. + * oriented services and is defined as:
  19682. + *
  19683. + * Even frames: M_T, C_T, N_T
  19684. + * Uneven frames: N_T
  19685. + *
  19686. + * Exception: M_T tails containing "bearer request" or "bearer release"
  19687. + * messages may be placed in any frame.
  19688. + */
  19689. +static struct sk_buff *dect_pt_t_mux(struct dect_cell *cell,
  19690. + struct dect_bearer *bearer)
  19691. +{
  19692. + struct dect_tbc *tbc = NULL;
  19693. + struct sk_buff *skb;
  19694. +
  19695. + switch (bearer->ops->state) {
  19696. + case DECT_DUMMY_BEARER:
  19697. + case DECT_CL_BEARER:
  19698. + case DECT_MONITOR_BEARER:
  19699. + WARN_ON(0);
  19700. + break;
  19701. + case DECT_TRAFFIC_BEARER:
  19702. + tbc = bearer->tbc;
  19703. + tbc->cs_tx_ok = false;
  19704. + break;
  19705. + }
  19706. +
  19707. + if ((dect_framenum(cell, DECT_TIMER_TX) & 0x1) == 0) {
  19708. + skb = skb_dequeue(&bearer->m_tx_queue);
  19709. + if (skb != NULL) {
  19710. + tmux_debug(cell, "M-channel\n");
  19711. + return skb;
  19712. + }
  19713. + if (tbc != NULL && tbc->cs_tx_skb != NULL) {
  19714. + skb = tbc->cs_tx_skb;
  19715. + tbc->cs_tx_skb = NULL;
  19716. + tbc->cs_tx_ok = true;
  19717. + tmux_debug(cell, "C-channel\n");
  19718. + return skb;
  19719. + }
  19720. + } else {
  19721. + skb = skb_peek(&bearer->m_tx_queue);
  19722. + if (skb != NULL && skb->priority == DECT_MT_HIGH_PRIORITY) {
  19723. + tmux_debug(cell, "M-channel (high priority)\n");
  19724. + skb_unlink(skb, &bearer->m_tx_queue);
  19725. + return skb;
  19726. + }
  19727. + }
  19728. +
  19729. + tmux_debug(cell, "N-channel\n");
  19730. + return dect_bc_dequeue(cell, bearer, &tbc->bc, DECT_MC_N);
  19731. +}
  19732. +
  19733. +/**
  19734. + * dect_rfp_t_mux - DECT T-MUX for RFP transmissions
  19735. + *
  19736. + * @cell: DECT cell
  19737. + * @bearer: MAC bearer
  19738. + *
  19739. + * The RFP T-MUX sequence is used for all RFP transmissions and is defined as:
  19740. + *
  19741. + * Frame 8: Q_T
  19742. + * Frame 14: N_T
  19743. + * Other even frames: P_T, N_T
  19744. + * Uneven frames: M_T, C_T, N_T
  19745. + *
  19746. + * Exception: M_T tails sent in response to "bearer request" messages or during
  19747. + * bearer release may be placed in any frame.
  19748. + */
  19749. +static struct sk_buff *dect_rfp_t_mux(struct dect_cell *cell,
  19750. + struct dect_bearer *bearer)
  19751. +{
  19752. + u8 framenum = dect_framenum(cell, DECT_TIMER_TX);
  19753. + struct dect_tbc *tbc = NULL;
  19754. + struct dect_bc *bc = NULL;
  19755. + struct sk_buff *skb;
  19756. +
  19757. + switch (bearer->ops->state) {
  19758. + case DECT_DUMMY_BEARER:
  19759. + bc = &bearer->dbc->bc;
  19760. + break;
  19761. + case DECT_TRAFFIC_BEARER:
  19762. + tbc = bearer->tbc;
  19763. + tbc->cs_tx_ok = false;
  19764. + bc = &bearer->tbc->bc;
  19765. + break;
  19766. + case DECT_CL_BEARER:
  19767. + case DECT_MONITOR_BEARER:
  19768. + break;
  19769. + }
  19770. +
  19771. + if ((framenum & 0x1) == 0) {
  19772. + skb = skb_peek(&bearer->m_tx_queue);
  19773. + if (skb != NULL && skb->priority == DECT_MT_HIGH_PRIORITY) {
  19774. + tmux_debug(cell, "M-channel (high priority)\n");
  19775. + skb_unlink(skb, &bearer->m_tx_queue);
  19776. + return skb;
  19777. + }
  19778. +
  19779. + if (framenum == 8) {
  19780. + tmux_debug(cell, "Q-channel\n");
  19781. + return dect_bc_dequeue(cell, bearer, bc, DECT_MC_Q);
  19782. + }
  19783. + if (framenum == 14) {
  19784. + tmux_debug(cell, "N-channel\n");
  19785. + return dect_bc_dequeue(cell, bearer, bc, DECT_MC_N);
  19786. + }
  19787. +
  19788. + skb = dect_bc_dequeue(cell, bearer, bc, DECT_MC_P);
  19789. + if (skb != NULL) {
  19790. + tmux_debug(cell, "P-channel\n");
  19791. + return skb;
  19792. + }
  19793. + } else {
  19794. + skb = skb_dequeue(&bearer->m_tx_queue);
  19795. + if (skb != NULL) {
  19796. + tmux_debug(cell, "M-channel\n");
  19797. + return skb;
  19798. + }
  19799. + if (tbc != NULL && tbc->cs_tx_skb != NULL) {
  19800. + skb = tbc->cs_tx_skb;
  19801. + tbc->cs_tx_skb = NULL;
  19802. + tbc->cs_tx_ok = true;
  19803. + tmux_debug(cell, "C-channel\n");
  19804. + return skb;
  19805. + }
  19806. + }
  19807. +
  19808. + tmux_debug(cell, "N-channel\n");
  19809. + return dect_bc_dequeue(cell, bearer, bc, DECT_MC_N);
  19810. +}
  19811. +
  19812. +/**
  19813. + * dect_a_map - DECT A-Field mapping
  19814. + *
  19815. + * @cell: DECT cell
  19816. + * @bearer: MAC bearer
  19817. + *
  19818. + * Combine the H-, T- and RA-Fields into the A-Field.
  19819. + */
  19820. +static struct sk_buff *dect_a_map(struct dect_cell *cell,
  19821. + struct dect_bearer *bearer)
  19822. +{
  19823. + struct sk_buff *skb;
  19824. +
  19825. + switch (cell->mode) {
  19826. + case DECT_MODE_PP:
  19827. + skb = dect_pt_t_mux(cell, bearer);
  19828. + break;
  19829. + case DECT_MODE_FP:
  19830. + skb = dect_rfp_t_mux(cell, bearer);
  19831. + break;
  19832. + default:
  19833. + skb = NULL;
  19834. + break;
  19835. + }
  19836. +
  19837. + if (skb == NULL)
  19838. + return NULL;
  19839. +
  19840. + /* Append empty RA-Field */
  19841. + memset(skb_put(skb, DECT_RA_FIELD_SIZE), 0, DECT_RA_FIELD_SIZE);
  19842. +
  19843. + /* Prepend Header field */
  19844. + skb_push(skb, DECT_HDR_FIELD_SIZE);
  19845. + skb->data[DECT_HDR_FIELD_OFF] = DECT_A_CB(skb)->id;
  19846. + skb->data[DECT_HDR_FIELD_OFF] |= bearer->q;
  19847. + bearer->q = 0;
  19848. + return skb;
  19849. +}
  19850. +
  19851. +static struct sk_buff *dect_raw_tx_peek(struct dect_cell *cell)
  19852. +{
  19853. + struct dect_timer_base *base = &cell->timer_base[DECT_TIMER_TX];
  19854. + struct dect_skb_trx_cb *cb;
  19855. + struct sk_buff *skb;
  19856. +
  19857. + skb = skb_peek(&cell->raw_tx_queue);
  19858. + if (skb == NULL)
  19859. + return NULL;
  19860. + cb = DECT_TRX_CB(skb);
  19861. +
  19862. + if ((!cb->mfn || cb->mfn == base->mfn) &&
  19863. + (!cb->frame || cb->frame == base->framenum) &&
  19864. + cb->slot == dect_slotnum(cell, DECT_TIMER_TX))
  19865. + return skb;
  19866. +
  19867. + return NULL;
  19868. +}
  19869. +
  19870. +static void dect_raw_tx_configure(struct dect_cell *cell,
  19871. + struct dect_transceiver *trx,
  19872. + struct dect_transceiver_slot *ts)
  19873. +{
  19874. + if (dect_raw_tx_peek(cell)) {
  19875. + if (ts->state == DECT_SLOT_RX) {
  19876. + tx_debug(cell, "enable raw TX\n");
  19877. + dect_set_channel_mode(trx, &ts->chd, DECT_SLOT_TX);
  19878. + dect_set_carrier(trx, ts->chd.slot, ts->chd.carrier);
  19879. + ts->priv_flags |= DECT_SLOT_RAW_TX;
  19880. + }
  19881. + } else if (ts->priv_flags & DECT_SLOT_RAW_TX) {
  19882. + tx_debug(cell, "disable raw TX\n");
  19883. + dect_set_channel_mode(trx, &ts->chd, DECT_SLOT_RX);
  19884. + dect_set_carrier(trx, ts->chd.slot, ts->chd.carrier);
  19885. + ts->priv_flags &= ~DECT_SLOT_RAW_TX;
  19886. + }
  19887. +}
  19888. +
  19889. +static struct sk_buff *dect_raw_tx(struct dect_cell *cell)
  19890. +{
  19891. + struct sk_buff *skb;
  19892. +
  19893. + skb = dect_raw_tx_peek(cell);
  19894. + if (skb == NULL)
  19895. + return NULL;
  19896. +
  19897. + tx_debug(cell, "raw transmit\n");
  19898. + skb_unlink(skb, &cell->raw_tx_queue);
  19899. + return skb;
  19900. +}
  19901. +
  19902. +/**
  19903. + * dect_d_map - DECT D-Field mapping
  19904. + *
  19905. + * @cell: DECT cell
  19906. + * @bearer: MAC bearer
  19907. + *
  19908. + * Combine the A- and B-Fields from their respective MAPs into one D-Field.
  19909. + */
  19910. +static struct sk_buff *dect_d_map(struct dect_cell *cell,
  19911. + struct dect_bearer *bearer)
  19912. +{
  19913. + struct sk_buff *skb_a, *skb_b, *skb;
  19914. +
  19915. + skb = dect_raw_tx(cell);
  19916. + if (skb != NULL)
  19917. + return skb;
  19918. +
  19919. + skb_a = dect_a_map(cell, bearer);
  19920. + if (skb_a == NULL)
  19921. + goto err1;
  19922. +
  19923. + if (bearer->chd.pkt != DECT_PACKET_P00) {
  19924. + skb_b = dect_b_map(cell, bearer);
  19925. + if (skb_b == NULL)
  19926. + goto err2;
  19927. + skb_a->data[DECT_HDR_BA_OFF] |= DECT_B_CB(skb_b)->id;
  19928. +
  19929. + skb = skb_append_frag(skb_a, skb_b);
  19930. + if (skb_linearize(skb) < 0) {
  19931. + kfree_skb(skb);
  19932. + skb = NULL;
  19933. + }
  19934. + } else {
  19935. + skb_a->data[DECT_HDR_BA_OFF] |= DECT_BI_NONE;
  19936. + skb = skb_a;
  19937. + }
  19938. +
  19939. + return skb;
  19940. +
  19941. +err2:
  19942. + kfree_skb(skb_a);
  19943. +err1:
  19944. + return NULL;
  19945. +}
  19946. +
  19947. +static void dect_mac_xmit_frame(struct dect_transceiver *trx,
  19948. + struct dect_transceiver_slot *ts)
  19949. +{
  19950. + struct dect_cell *cell = trx->cell;
  19951. + struct dect_bearer *bearer = ts->bearer;
  19952. + struct sk_buff *skb;
  19953. +
  19954. + skb = dect_d_map(cell, bearer);
  19955. + if (skb == NULL)
  19956. + return;
  19957. +
  19958. + tx_debug(cell, "%s: Q1: %d Q2: %d A/B: %02x carrier: %u PSCN: %u\n",
  19959. + trx->name,
  19960. + skb->data[DECT_HDR_Q1_OFF] & DECT_HDR_Q1_FLAG ? 1 : 0,
  19961. + skb->data[DECT_HDR_Q2_OFF] & DECT_HDR_Q2_FLAG ? 1 : 0,
  19962. + skb->data[DECT_HDR_TA_OFF] &
  19963. + (DECT_HDR_TA_MASK | DECT_HDR_BA_MASK),
  19964. + ts->chd.carrier, cell->si.ssi.pscn);
  19965. +
  19966. + switch (cell->mode) {
  19967. + case DECT_MODE_FP:
  19968. + skb->mac_len = sizeof(dect_fp_preamble);
  19969. + memcpy(skb_mac_header(skb), dect_fp_preamble, skb->mac_len);
  19970. + break;
  19971. + case DECT_MODE_PP:
  19972. + skb->mac_len = sizeof(dect_pp_preamble);
  19973. + memcpy(skb_mac_header(skb), dect_pp_preamble, skb->mac_len);
  19974. + break;
  19975. + }
  19976. +
  19977. + DECT_TRX_CB(skb)->trx = trx;
  19978. + DECT_TRX_CB(skb)->slot = ts->chd.slot;
  19979. + DECT_TRX_CB(skb)->frame = dect_framenum(cell, DECT_TIMER_TX);
  19980. + DECT_TRX_CB(skb)->mfn = dect_mfn(cell, DECT_TIMER_TX);
  19981. + dect_raw_rcv(skb);
  19982. +
  19983. + dect_transceiver_tx(trx, skb);
  19984. +}
  19985. +
  19986. +void dect_mac_rcv(struct dect_transceiver *trx,
  19987. + struct dect_transceiver_slot *ts,
  19988. + struct sk_buff *skb)
  19989. +{
  19990. + struct dect_cell *cell = trx->cell;
  19991. +
  19992. + DECT_TRX_CB(skb)->frame = dect_framenum(cell, DECT_TIMER_RX);
  19993. + DECT_TRX_CB(skb)->mfn = dect_mfn(cell, DECT_TIMER_RX);
  19994. +
  19995. + /* TX bearers can temporarily switch to RX mode for noise measurement */
  19996. + if (ts->bearer != NULL &&
  19997. + ts->bearer->mode == DECT_BEARER_RX) {
  19998. + rx_debug(cell, "%s: Q1: %d Q2: %d A/B: %02x carrier: %u %s%s%s",
  19999. + trx->name,
  20000. + skb->data[DECT_HDR_Q1_OFF] & DECT_HDR_Q1_FLAG ? 1 : 0,
  20001. + skb->data[DECT_HDR_Q2_OFF] & DECT_HDR_Q2_FLAG ? 1 : 0,
  20002. + skb->data[DECT_HDR_TA_OFF] &
  20003. + (DECT_HDR_TA_MASK | DECT_HDR_BA_MASK), ts->chd.carrier,
  20004. + DECT_TRX_CB(skb)->csum & DECT_CHECKSUM_A_CRC_OK ?
  20005. + "" : "A-CRC: 0 ",
  20006. + ts->chd.pkt == DECT_PACKET_P00 ||
  20007. + DECT_TRX_CB(skb)->csum & DECT_CHECKSUM_X_CRC_OK ?
  20008. + "" : "X-CRC: 0 ",
  20009. + ts->chd.pkt == DECT_PACKET_P00 ||
  20010. + DECT_TRX_CB(skb)->csum & DECT_CHECKSUM_Z_CRC_OK ?
  20011. + "" : "Z-CRC: 0 ");
  20012. +
  20013. + ts->bearer->ops->rcv(cell, ts->bearer, skb);
  20014. + } else
  20015. + kfree_skb(skb);
  20016. +}
  20017. +
  20018. +void dect_mac_report_rssi(struct dect_transceiver *trx,
  20019. + struct dect_transceiver_slot *ts,
  20020. + u8 rssi)
  20021. +{
  20022. + struct dect_cell *cell = trx->cell;
  20023. +
  20024. + if (ts->bearer == NULL) {
  20025. + pr_debug("%s: RSSI: slot: %u carrier: %u state: %u no bearer\n",
  20026. + trx->name, ts->chd.slot, ts->chd.carrier, ts->state);
  20027. + return;
  20028. + }
  20029. + if (ts->bearer->state != DECT_BEARER_ENABLED)
  20030. + dect_tx_bearer_report_rssi(cell, ts->bearer, rssi);
  20031. + else if (ts->bearer->ops->report_rssi != NULL)
  20032. + ts->bearer->ops->report_rssi(cell, ts->bearer, ts->chd.slot, rssi);
  20033. +}
  20034. +
  20035. +static void dect_fp_state_process(struct dect_cell *cell)
  20036. +{
  20037. + if (list_empty(&cell->dbcs))
  20038. + dect_dbc_init(cell, NULL);
  20039. +
  20040. + if (time_before(cell->bfs_xmit_stamp + HZ, jiffies)) {
  20041. + dect_cell_schedule_page(cell, (1 << DECT_TM_TYPE_BFS) |
  20042. + (1 << DECT_TM_TYPE_BD));
  20043. + cell->bfs_xmit_stamp = jiffies;
  20044. + }
  20045. +}
  20046. +
  20047. +static bool dect_pp_idle_timeout(const struct dect_cell *cell)
  20048. +{
  20049. + u32 mfn;
  20050. +
  20051. + mfn = dect_mfn_add(cell->timer_sync_stamp, DECT_CELL_TIMER_RESYNC_TIMEOUT);
  20052. + if (dect_mfn_after(dect_mfn(cell, DECT_TIMER_RX), mfn) ||
  20053. + time_after(jiffies, cell->a_rcv_stamp + DECT_CELL_A_RCV_TIMEOUT) ||
  20054. + time_after(jiffies, cell->nt_rcv_stamp + DECT_CELL_NT_RCV_TIMEOUT)) {
  20055. + pr_debug("timeout, unlock, a: %ld nt: %ld mfn: %d\n",
  20056. + jiffies - cell->a_rcv_stamp, jiffies - cell->nt_rcv_stamp,
  20057. + dect_mfn(cell, DECT_TIMER_RX) - cell->timer_sync_stamp);
  20058. + return true;
  20059. + }
  20060. +
  20061. + return false;
  20062. +}
  20063. +
  20064. +static void dect_pp_state_process(struct dect_cell *cell)
  20065. +{
  20066. + struct dect_transceiver *trx = cell->trg.trx[0];
  20067. + struct dect_dbc *dbc, *next;
  20068. +
  20069. + if (cell->tbc_num_est || !list_empty(&cell->dmbs)) {
  20070. + /* Active locked state: release DBCs */
  20071. + list_for_each_entry_safe(dbc, next, &cell->dbcs, list)
  20072. + dect_dbc_release(dbc);
  20073. + } else if (trx->state == DECT_TRANSCEIVER_LOCKED) {
  20074. + /* Idle locked state: install DBC if none present */
  20075. + if (list_empty(&cell->dbcs) &&
  20076. + list_empty(&cell->tbcs) &&
  20077. + list_empty(&cell->dmbs)) {
  20078. + struct dect_channel_desc chd;
  20079. +
  20080. + chd.pkt = DECT_PACKET_P00;
  20081. + chd.b_fmt = DECT_B_NONE;
  20082. + chd.slot = cell->tbc_last_chd.slot;
  20083. + chd.carrier = cell->tbc_last_chd.carrier;
  20084. +
  20085. + dect_dbc_init(cell, &chd);
  20086. + }
  20087. +
  20088. + if (!list_empty(&cell->dbcs) && dect_pp_idle_timeout(cell)) {
  20089. + list_for_each_entry_safe(dbc, next, &cell->dbcs, list)
  20090. + dect_dbc_release(dbc);
  20091. +
  20092. + dect_irc_disable(cell, trx->irc);
  20093. + dect_transceiver_unlock(trx);
  20094. +
  20095. + dect_chl_flush(cell);
  20096. + /* Clear system information */
  20097. + memset(&cell->si, 0, sizeof(cell->si));
  20098. + dect_cell_mac_info_ind(cell);
  20099. +
  20100. + dect_attempt_lock(cell, trx);
  20101. + }
  20102. + }
  20103. +}
  20104. +
  20105. +static void dect_cell_state_process(struct dect_cell *cell)
  20106. +{
  20107. + if (list_empty(&cell->chanlists) && list_empty(&cell->chl_pending)) {
  20108. + dect_chl_schedule_update(cell, DECT_PACKET_P00);
  20109. + dect_chl_schedule_update(cell, DECT_PACKET_P32);
  20110. + if (cell->trg.features & DECT_TRANSCEIVER_PACKET_P64 &&
  20111. + cell->si.efpc2.fpc & DECT_EFPC2_LONG_SLOT_J640)
  20112. + dect_chl_schedule_update(cell, DECT_PACKET_P640j);
  20113. + }
  20114. +
  20115. + switch (cell->mode) {
  20116. + case DECT_MODE_FP:
  20117. + return dect_fp_state_process(cell);
  20118. + case DECT_MODE_PP:
  20119. + return dect_pp_state_process(cell);
  20120. + }
  20121. +}
  20122. +
  20123. +static void dect_cluster_time_ind(struct dect_cell *cell,
  20124. + enum dect_timer_bases base,
  20125. + u8 slot)
  20126. +{
  20127. + struct dect_cluster_handle *clh = cell->handle.clh;
  20128. +
  20129. + clh->ops->time_ind(clh, base,
  20130. + dect_mfn(cell, base),
  20131. + dect_framenum(cell, base),
  20132. + slot);
  20133. +}
  20134. +
  20135. +void dect_mac_rx_tick(struct dect_transceiver_group *grp, u8 slot)
  20136. +{
  20137. + struct dect_cell *cell = container_of(grp, struct dect_cell, trg);
  20138. +
  20139. + dect_run_timers(cell, DECT_TIMER_RX);
  20140. + dect_timer_base_update(cell, DECT_TIMER_RX, slot);
  20141. + dect_cluster_time_ind(cell, DECT_TIMER_RX, slot);
  20142. +}
  20143. +
  20144. +void dect_mac_tx_tick(struct dect_transceiver_group *grp, u8 slot)
  20145. +{
  20146. + struct dect_cell *cell = container_of(grp, struct dect_cell, trg);
  20147. + struct dect_transceiver_slot *ts;
  20148. + struct dect_transceiver *trx;
  20149. + u8 scn;
  20150. +
  20151. + /* TX timers run at the beginning of a slot, update the time first */
  20152. + dect_timer_base_update(cell, DECT_TIMER_TX, slot);
  20153. + dect_cluster_time_ind(cell, DECT_TIMER_TX, slot);
  20154. + dect_run_timers(cell, DECT_TIMER_TX);
  20155. +
  20156. + dect_cell_state_process(cell);
  20157. +
  20158. + dect_foreach_transceiver(trx, grp) {
  20159. + if (trx->state != DECT_TRANSCEIVER_LOCKED)
  20160. + continue;
  20161. + ts = &trx->slots[slot];
  20162. +
  20163. + dect_raw_tx_configure(cell, trx, ts);
  20164. +
  20165. + switch (ts->state) {
  20166. + case DECT_SLOT_SCANNING:
  20167. + scn = trx->irc->tx_scn;
  20168. +
  20169. + if (cell->flags & DECT_CELL_MONITOR &&
  20170. + slot >= DECT_HALF_FRAME_SIZE)
  20171. + scn = dect_prev_carrier(cell->si.ssi.rfcars, scn);
  20172. +
  20173. + dect_set_carrier(trx, slot, scn);
  20174. + break;
  20175. + case DECT_SLOT_TX:
  20176. + dect_mac_xmit_frame(trx, ts);
  20177. + break;
  20178. + }
  20179. + }
  20180. +
  20181. + if (slot == DECT_FRAME_SIZE - 1)
  20182. + cell->si.ssi.pscn = dect_next_carrier(cell->si.ssi.rfcars,
  20183. + cell->si.ssi.pscn);
  20184. +}
  20185. +
  20186. +static void dect_fp_init_primary(struct dect_cell *cell,
  20187. + struct dect_transceiver *trx)
  20188. +{
  20189. + dect_transceiver_enable(trx);
  20190. + dect_irc_enable(cell, trx->irc);
  20191. +}
  20192. +
  20193. +static void dect_cell_enable_transceiver(struct dect_cell *cell,
  20194. + struct dect_transceiver *trx)
  20195. +{
  20196. + /* The primary transceiver of a FP is a timing master. All other
  20197. + * transceivers need to synchronize.
  20198. + */
  20199. + if (trx->index == 0 && cell->mode == DECT_MODE_FP &&
  20200. + !(cell->flags & DECT_CELL_SLAVE)) {
  20201. + trx->mode = DECT_TRANSCEIVER_MASTER;
  20202. + dect_fp_init_primary(cell, trx);
  20203. + } else {
  20204. + trx->mode = DECT_TRANSCEIVER_SLAVE;
  20205. + dect_attempt_lock(cell, trx);
  20206. + }
  20207. +}
  20208. +
  20209. +static int dect_cell_preload(const struct dect_cell_handle *ch,
  20210. + const struct dect_ari *pari, u8 rpn,
  20211. + const struct dect_si *si)
  20212. +{
  20213. + struct dect_cell *cell = dect_cell(ch);
  20214. +
  20215. + /* Initialise identity */
  20216. + spin_lock_bh(&cell->lock);
  20217. + cell->idi.e = false;
  20218. + memcpy(&cell->idi.pari, pari, sizeof(cell->idi.pari));
  20219. + cell->idi.rpn = rpn;
  20220. + cell->fmid = dect_build_fmid(&cell->idi);
  20221. +
  20222. + cell->si.ssi.rfcars = 0x3ff;
  20223. + memcpy(&cell->si.erfc, &si->erfc, sizeof(cell->si.erfc));
  20224. + memcpy(&cell->si.fpc, &si->fpc, sizeof(cell->si.fpc));
  20225. + memcpy(&cell->si.efpc, &si->efpc, sizeof(cell->si.efpc));
  20226. + memcpy(&cell->si.efpc2, &si->efpc2, sizeof(cell->si.efpc2));
  20227. + memcpy(&cell->si.mfn, &si->mfn, sizeof(cell->si.mfn));
  20228. + memcpy(cell->si.sari, si->sari, sizeof(cell->si.sari));
  20229. + cell->si.num_saris = si->num_saris;
  20230. + dect_timer_synchronize_mfn(cell, cell->si.mfn.num);
  20231. + spin_unlock_bh(&cell->lock);
  20232. + return 0;
  20233. +}
  20234. +
  20235. +static int dect_cell_enable(const struct dect_cell_handle *ch)
  20236. +{
  20237. + struct dect_cell *cell = dect_cell(ch);
  20238. + struct dect_transceiver *trx;
  20239. +
  20240. + cell->state |= DECT_CELL_ENABLED;
  20241. + dect_foreach_transceiver(trx, &cell->trg) {
  20242. + dect_cell_enable_transceiver(cell, trx);
  20243. + if (cell->mode == DECT_MODE_PP)
  20244. + break;
  20245. + }
  20246. + return 0;
  20247. +}
  20248. +
  20249. +static void dect_scan_report(struct dect_cell *cell,
  20250. + struct dect_transceiver *trx,
  20251. + enum dect_scan_status status)
  20252. +{
  20253. + const struct dect_cluster_handle *clh = cell->handle.clh;
  20254. + const struct dect_irc *irc = trx->irc;
  20255. + struct dect_scan_result res;
  20256. +
  20257. + switch (status) {
  20258. + case DECT_SCAN_FAIL:
  20259. + break;
  20260. + case DECT_SCAN_TIMEOUT:
  20261. + pr_debug("timeout\n");
  20262. + case DECT_SCAN_COMPLETE:
  20263. + res.lreq = irc->lreq;
  20264. + res.rssi = irc->rssi;
  20265. + res.idi = irc->idi;
  20266. + res.si = irc->si;
  20267. + clh->ops->scan_report(clh, &res);
  20268. + break;
  20269. + }
  20270. +
  20271. + return dect_restart_scan(cell, trx);
  20272. +}
  20273. +
  20274. +static int dect_cell_scan(const struct dect_cell_handle *ch,
  20275. + const struct dect_llme_req *lreq,
  20276. + const struct dect_ari *pari,
  20277. + const struct dect_ari *pari_mask)
  20278. +{
  20279. + struct dect_cell *cell = dect_cell(ch);
  20280. + struct dect_transceiver *trx = cell->trg.trx[0];
  20281. +
  20282. + if (trx == NULL)
  20283. + return -ENODEV;
  20284. + // FIXME
  20285. + memcpy(&trx->irc->lreq, lreq, sizeof(trx->irc->lreq));
  20286. + dect_initiate_scan(trx, pari, pari_mask, dect_scan_report);
  20287. + return 0;
  20288. +}
  20289. +
  20290. +static int dect_cell_set_mode(const struct dect_cell_handle *ch,
  20291. + enum dect_cluster_modes mode)
  20292. +{
  20293. + struct dect_cell *cell = dect_cell(ch);
  20294. +
  20295. + cell->mode = mode;
  20296. + return 0;
  20297. +}
  20298. +
  20299. +static void dect_cell_page_req(const struct dect_cell_handle *ch,
  20300. + struct sk_buff *skb)
  20301. +{
  20302. + struct dect_cell *cell = dect_cell(ch);
  20303. +
  20304. + DECT_BMC_CB(skb)->stamp = dect_mfn(cell, DECT_TIMER_TX);
  20305. + dect_queue_page(cell, skb);
  20306. +}
  20307. +
  20308. +static const struct dect_csf_ops dect_csf_ops = {
  20309. + .set_mode = dect_cell_set_mode,
  20310. + .scan = dect_cell_scan,
  20311. + .enable = dect_cell_enable,
  20312. + .preload = dect_cell_preload,
  20313. + .page_req = dect_cell_page_req,
  20314. + .tbc_establish_req = dect_tbc_establish_req,
  20315. + .tbc_establish_res = dect_tbc_establish_res,
  20316. + .tbc_dis_req = dect_tbc_dis_req,
  20317. + .tbc_enc_key_req = dect_tbc_enc_key_req,
  20318. + .tbc_enc_eks_req = dect_tbc_enc_eks_req,
  20319. + .tbc_enc_req = dect_tbc_enc_req,
  20320. + .tbc_data_req = dect_tbc_data_req,
  20321. +};
  20322. +
  20323. +static int dect_cell_bind(struct dect_cell *cell, u8 index)
  20324. +{
  20325. + struct dect_cluster_handle *clh;
  20326. + struct dect_cluster *cl;
  20327. +
  20328. + if (cell->flags & DECT_CELL_CCP) {
  20329. + clh = dect_ccp_cell_init(cell, index);
  20330. + if (IS_ERR(clh))
  20331. + return PTR_ERR(clh);
  20332. + } else {
  20333. + cl = dect_cluster_get_by_index(index);
  20334. + if (cl == NULL)
  20335. + return -ENOENT;
  20336. + clh = &cl->handle;
  20337. + }
  20338. +
  20339. + return clh->ops->bind(clh, &cell->handle);
  20340. +}
  20341. +
  20342. +static void dect_cell_shutdown(struct dect_cell *cell)
  20343. +{
  20344. + struct dect_cluster_handle *clh = cell->handle.clh;
  20345. + struct dect_transceiver *trx;
  20346. +
  20347. + if (clh != NULL)
  20348. + clh->ops->unbind(clh, &cell->handle);
  20349. +
  20350. + dect_foreach_transceiver(trx, &cell->trg)
  20351. + dect_cell_detach_transceiver(cell, trx);
  20352. + dect_cell_bmc_disable(cell);
  20353. + skb_queue_purge(&cell->raw_tx_queue);
  20354. + dect_chl_flush(cell);
  20355. +}
  20356. +
  20357. +/**
  20358. + * dect_mac_init_cell - Initialize a DECT cell
  20359. + */
  20360. +static void dect_cell_init(struct dect_cell *cell)
  20361. +{
  20362. + spin_lock_init(&cell->lock);
  20363. + INIT_LIST_HEAD(&cell->bcs);
  20364. + INIT_LIST_HEAD(&cell->dbcs);
  20365. + INIT_LIST_HEAD(&cell->tbcs);
  20366. + INIT_LIST_HEAD(&cell->dmbs);
  20367. + INIT_LIST_HEAD(&cell->chl_pending);
  20368. + INIT_LIST_HEAD(&cell->chanlists);
  20369. + dect_timer_base_init(cell->timer_base, DECT_TIMER_TX);
  20370. + dect_timer_base_init(cell->timer_base, DECT_TIMER_RX);
  20371. + skb_queue_head_init(&cell->raw_tx_queue);
  20372. + dect_cell_bmc_init(cell);
  20373. + cell->blind_full_slots = (1 << DECT_HALF_FRAME_SIZE) - 1;
  20374. + cell->trg_blind_full_slots = (1 << DECT_HALF_FRAME_SIZE) - 1;
  20375. + dect_transceiver_group_init(&cell->trg);
  20376. + cell->handle.ops = &dect_csf_ops;
  20377. +}
  20378. +
  20379. +/**
  20380. + * dect_cell_attach_transceiver - attach a transceiver to a DECT cell
  20381. + *
  20382. + * Attach the transceiver to the cell's transceiver group and initialize
  20383. + * an idle receiver control instance.
  20384. + */
  20385. +int dect_cell_attach_transceiver(struct dect_cell *cell,
  20386. + struct dect_transceiver *trx)
  20387. +{
  20388. + int err;
  20389. +
  20390. + if (trx->cell != NULL)
  20391. + return -EBUSY;
  20392. +
  20393. + err = dect_transceiver_group_add(&cell->trg, trx);
  20394. + if (err < 0)
  20395. + goto err1;
  20396. +
  20397. + err = -ENOMEM;
  20398. + if (!dect_irc_init(cell, trx))
  20399. + goto err2;
  20400. +
  20401. + trx->cell = cell;
  20402. + if (cell->state & DECT_CELL_ENABLED)
  20403. + dect_cell_enable_transceiver(cell, trx);
  20404. +
  20405. + return 0;
  20406. +
  20407. +err2:
  20408. + dect_transceiver_group_remove(&cell->trg, trx);
  20409. +err1:
  20410. + return err;
  20411. +}
  20412. +
  20413. +/**
  20414. + * dect_cell_detach_transceiver - detach a transceiver from a DECT cell
  20415. + *
  20416. + * Detach the transceiver from the cell's transceiver group and release
  20417. + * the associated resources.
  20418. + */
  20419. +void dect_cell_detach_transceiver(struct dect_cell *cell,
  20420. + struct dect_transceiver *trx)
  20421. +{
  20422. + dect_irc_disable(cell, trx->irc);
  20423. + dect_transceiver_disable(trx);
  20424. + dect_transceiver_group_remove(&cell->trg, trx);
  20425. + kfree(trx->irc);
  20426. + trx->cell = NULL;
  20427. +
  20428. + dect_notify_cell(DECT_NEW_CELL, cell, NULL, 0);
  20429. +}
  20430. +
  20431. +/*
  20432. + * Cell netlink interface
  20433. + */
  20434. +
  20435. +static u32 dect_cell_alloc_index(void)
  20436. +{
  20437. + static u32 index;
  20438. +
  20439. + for (;;) {
  20440. + if (++index == 0)
  20441. + index = 1;
  20442. + if (!dect_cell_get_by_index(index))
  20443. + return index;
  20444. + }
  20445. +}
  20446. +
  20447. +static int dect_fill_cell(struct sk_buff *skb,
  20448. + const struct dect_cell *cell,
  20449. + u16 type, u32 portid, u32 seq, u16 flags)
  20450. +{
  20451. + const struct dect_transceiver *trx;
  20452. + struct nlmsghdr *nlh;
  20453. + struct dectmsg *dm;
  20454. + struct nlattr *nest;
  20455. +
  20456. + nlh = nlmsg_put(skb, portid, seq, type, sizeof(*dm), flags);
  20457. + if (nlh == NULL)
  20458. + return -EMSGSIZE;
  20459. + dm = nlmsg_data(nlh);
  20460. + dm->dm_index = cell->index;
  20461. +
  20462. + if (nla_put_string(skb, DECTA_CELL_NAME, cell->name))
  20463. + goto nla_put_failure;
  20464. + if (cell->flags != 0) {
  20465. + if (nla_put_u32(skb, DECTA_CELL_FLAGS, cell->flags))
  20466. + goto nla_put_failure;
  20467. + }
  20468. + if (cell->trg.trxmask != 0) {
  20469. + nest = nla_nest_start(skb, DECTA_CELL_TRANSCEIVERS);
  20470. + if (nest == NULL)
  20471. + goto nla_put_failure;
  20472. + dect_foreach_transceiver(trx, &cell->trg)
  20473. + if (nla_put_string(skb, DECTA_LIST_ELEM, trx->name))
  20474. + goto nla_put_failure;
  20475. + nla_nest_end(skb, nest);
  20476. + }
  20477. + if (cell->handle.clh != NULL) {
  20478. + if (nla_put_u8(skb, DECTA_CELL_CLUSTER,
  20479. + cell->handle.clh->index))
  20480. + goto nla_put_failure;
  20481. + }
  20482. +
  20483. + nlmsg_end(skb, nlh);
  20484. + return skb->len;
  20485. +
  20486. +nla_put_failure:
  20487. + nlmsg_cancel(skb, nlh);
  20488. + return -EMSGSIZE;
  20489. +}
  20490. +
  20491. +static int dect_dump_cell(struct sk_buff *skb,
  20492. + struct netlink_callback *cb)
  20493. +{
  20494. + const struct dect_cell *cell;
  20495. + unsigned int idx, s_idx;
  20496. +
  20497. + s_idx = cb->args[0];
  20498. + idx = 0;
  20499. + list_for_each_entry(cell, &dect_cell_list, list) {
  20500. + if (idx < s_idx)
  20501. + goto cont;
  20502. + if (dect_fill_cell(skb, cell, DECT_NEW_CELL,
  20503. + NETLINK_CB(cb->skb).portid,
  20504. + cb->nlh->nlmsg_seq, NLM_F_MULTI) <= 0)
  20505. + break;
  20506. +cont:
  20507. + idx++;
  20508. + }
  20509. + cb->args[0] = idx;
  20510. +
  20511. + return skb->len;
  20512. +}
  20513. +
  20514. +static void dect_notify_cell(u16 event, const struct dect_cell *cell,
  20515. + const struct nlmsghdr *nlh, u32 portid)
  20516. +{
  20517. + struct sk_buff *skb;
  20518. + bool report = nlh ? nlmsg_report(nlh) : 0;
  20519. + u32 seq = nlh ? nlh->nlmsg_seq : 0;
  20520. + int err = -ENOBUFS;
  20521. +
  20522. + skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
  20523. + if (skb == NULL)
  20524. + goto err;
  20525. +
  20526. + err = dect_fill_cell(skb, cell, event, portid, seq, NLMSG_DONE);
  20527. + if (err < 0) {
  20528. + WARN_ON(err == -EMSGSIZE);
  20529. + kfree_skb(skb);
  20530. + goto err;
  20531. + }
  20532. + nlmsg_notify(dect_nlsk, skb, portid, DECTNLGRP_CELL, report,
  20533. + GFP_KERNEL);
  20534. +err:
  20535. + if (err < 0)
  20536. + netlink_set_err(dect_nlsk, portid, DECTNLGRP_CELL, err);
  20537. +}
  20538. +
  20539. +static const struct nla_policy dect_cell_policy[DECTA_CELL_MAX + 1] = {
  20540. + [DECTA_CELL_NAME] = { .type = NLA_STRING, .len = DECTNAMSIZ },
  20541. + [DECTA_CELL_FLAGS] = { .type = NLA_U32 },
  20542. + [DECTA_CELL_CLUSTER] = { .type = NLA_U8 },
  20543. +};
  20544. +
  20545. +static int dect_new_cell(const struct sk_buff *skb,
  20546. + const struct nlmsghdr *nlh,
  20547. + const struct nlattr *tb[DECTA_CELL_MAX + 1])
  20548. +{
  20549. + struct dect_cell *cell;
  20550. + struct dectmsg *dm;
  20551. + u32 flags = 0;
  20552. + u8 cli = 0;
  20553. + int err;
  20554. +
  20555. + dm = nlmsg_data(nlh);
  20556. + if (dm->dm_index != 0)
  20557. + cell = dect_cell_get_by_index(dm->dm_index);
  20558. + else if (tb[DECTA_CELL_NAME] != NULL)
  20559. + cell = dect_cell_get_by_name(tb[DECTA_CELL_NAME]);
  20560. + else
  20561. + return -EINVAL;
  20562. +
  20563. + if (tb[DECTA_CELL_FLAGS] != NULL) {
  20564. + flags = nla_get_u32(tb[DECTA_CELL_FLAGS]);
  20565. + if (flags & ~(DECT_CELL_CCP | DECT_CELL_SLAVE |
  20566. + DECT_CELL_MONITOR))
  20567. + return -EINVAL;
  20568. + }
  20569. +
  20570. + if (tb[DECTA_CELL_CLUSTER] != NULL)
  20571. + cli = nla_get_u8(tb[DECTA_CELL_CLUSTER]);
  20572. +
  20573. + if (cell != NULL) {
  20574. + if (nlh->nlmsg_flags & NLM_F_EXCL)
  20575. + return -EEXIST;
  20576. +
  20577. + if (tb[DECTA_CELL_CLUSTER] != NULL) {
  20578. + if (cell->handle.clh != NULL)
  20579. + return -EBUSY;
  20580. + if (cli != 0)
  20581. + return dect_cell_bind(cell, cli);
  20582. + }
  20583. + return 0;
  20584. + }
  20585. +
  20586. + if (!(nlh->nlmsg_flags & NLM_F_CREATE))
  20587. + return -ENOENT;
  20588. +
  20589. + cell = kzalloc(sizeof(*cell), GFP_KERNEL);
  20590. + if (cell == NULL)
  20591. + return -ENOMEM;
  20592. + cell->index = dect_cell_alloc_index();
  20593. + nla_strlcpy(cell->name, tb[DECTA_CELL_NAME], sizeof(cell->name));
  20594. + cell->flags = flags;
  20595. + dect_cell_init(cell);
  20596. +
  20597. + if (cli != 0) {
  20598. + err = dect_cell_bind(cell, cli);
  20599. + if (err < 0)
  20600. + goto err;
  20601. + }
  20602. +
  20603. + list_add_tail(&cell->list, &dect_cell_list);
  20604. + dect_notify_cell(DECT_NEW_CELL, cell, nlh, NETLINK_CB(skb).portid);
  20605. + return 0;
  20606. +
  20607. +err:
  20608. + kfree(cell);
  20609. + return err;
  20610. +}
  20611. +
  20612. +static int dect_del_cell(const struct sk_buff *skb,
  20613. + const struct nlmsghdr *nlh,
  20614. + const struct nlattr *tb[DECTA_CELL_MAX + 1])
  20615. +{
  20616. + struct dect_cell *cell = NULL;
  20617. + struct dectmsg *dm;
  20618. +
  20619. + dm = nlmsg_data(nlh);
  20620. + if (dm->dm_index != 0)
  20621. + cell = dect_cell_get_by_index(dm->dm_index);
  20622. + else if (tb[DECTA_CELL_NAME] != NULL)
  20623. + cell = dect_cell_get_by_name(tb[DECTA_CELL_NAME]);
  20624. + if (cell == NULL)
  20625. + return -ENODEV;
  20626. +
  20627. + cell = dect_cell_get_by_name(tb[DECTA_CELL_NAME]);
  20628. + if (cell == NULL)
  20629. + return -ENOENT;
  20630. +
  20631. + dect_cell_shutdown(cell);
  20632. + list_del(&cell->list);
  20633. + dect_notify_cell(DECT_DEL_CELL, cell, nlh, NETLINK_CB(skb).portid);
  20634. + kfree(cell);
  20635. + return 0;
  20636. +}
  20637. +
  20638. +static int dect_get_cell(const struct sk_buff *in_skb,
  20639. + const struct nlmsghdr *nlh,
  20640. + const struct nlattr *tb[DECTA_CELL_MAX + 1])
  20641. +{
  20642. + u32 portid = NETLINK_CB(in_skb).portid;
  20643. + const struct dect_cell *cell = NULL;
  20644. + struct dectmsg *dm;
  20645. + struct sk_buff *skb;
  20646. + int err;
  20647. +
  20648. + dm = nlmsg_data(nlh);
  20649. + if (dm->dm_index != 0)
  20650. + cell = dect_cell_get_by_index(dm->dm_index);
  20651. + else if (tb[DECTA_CELL_NAME] != NULL)
  20652. + cell = dect_cell_get_by_name(tb[DECTA_CELL_NAME]);
  20653. + if (cell == NULL)
  20654. + return -ENODEV;
  20655. +
  20656. + skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
  20657. + if (skb == NULL)
  20658. + return -ENOMEM;
  20659. + err = dect_fill_cell(skb, cell, DECT_NEW_CELL, portid, nlh->nlmsg_seq,
  20660. + NLMSG_DONE);
  20661. + if (err < 0)
  20662. + goto err1;
  20663. + return nlmsg_unicast(dect_nlsk, skb, portid);
  20664. +
  20665. +err1:
  20666. + kfree_skb(skb);
  20667. + return err;
  20668. +}
  20669. +
  20670. +static const struct dect_netlink_handler dect_cell_handlers[] = {
  20671. + {
  20672. + /* DECT_NEW_CELL */
  20673. + .policy = dect_cell_policy,
  20674. + .maxtype = DECTA_CELL_MAX,
  20675. + .doit = dect_new_cell,
  20676. + },
  20677. + {
  20678. + /* DECT_DEL_CELL */
  20679. + .policy = dect_cell_policy,
  20680. + .maxtype = DECTA_CELL_MAX,
  20681. + .doit = dect_del_cell,
  20682. + },
  20683. + {
  20684. + /* DECT_GET_CELL */
  20685. + .policy = dect_cell_policy,
  20686. + .maxtype = DECTA_CELL_MAX,
  20687. + .doit = dect_get_cell,
  20688. + .dump = dect_dump_cell,
  20689. + },
  20690. +};
  20691. +
  20692. +static int __init dect_csf_module_init(void)
  20693. +{
  20694. + int err;
  20695. +
  20696. + err = dect_transceiver_module_init();
  20697. + if (err < 0)
  20698. + return err;
  20699. +
  20700. + dect_netlink_register_handlers(dect_cell_handlers, DECT_NEW_CELL,
  20701. + ARRAY_SIZE(dect_cell_handlers));
  20702. + return 0;
  20703. +}
  20704. +
  20705. +static void __exit dect_csf_module_exit(void)
  20706. +{
  20707. + dect_netlink_unregister_handlers(DECT_NEW_CELL,
  20708. + ARRAY_SIZE(dect_cell_handlers));
  20709. + dect_transceiver_module_exit();
  20710. +}
  20711. +
  20712. +module_init(dect_csf_module_init);
  20713. +module_exit(dect_csf_module_exit);
  20714. +MODULE_LICENSE("GPL");
  20715. diff --git a/net/dect/raw.c b/net/dect/raw.c
  20716. new file mode 100644
  20717. index 0000000..97ccf71
  20718. --- /dev/null
  20719. +++ b/net/dect/raw.c
  20720. @@ -0,0 +1,267 @@
  20721. +/*
  20722. + * DECT RAW sockets
  20723. + *
  20724. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  20725. + *
  20726. + * This program is free software; you can redistribute it and/or modify
  20727. + * it under the terms of the GNU General Public License version 2 as
  20728. + * published by the Free Software Foundation.
  20729. + */
  20730. +
  20731. +#include <linux/kernel.h>
  20732. +#include <linux/module.h>
  20733. +#include <linux/init.h>
  20734. +#include <linux/socket.h>
  20735. +#include <linux/net.h>
  20736. +#include <linux/dect.h>
  20737. +#include <net/sock.h>
  20738. +#include <net/dect/dect.h>
  20739. +#include <net/dect/mac_csf.h>
  20740. +
  20741. +static HLIST_HEAD(dect_raw_sockets);
  20742. +
  20743. +struct dect_raw_sk {
  20744. + struct sock sk;
  20745. +};
  20746. +
  20747. +static inline struct dect_raw_sk *dect_raw_sk(struct sock *sk)
  20748. +{
  20749. + return (struct dect_raw_sk *)sk;
  20750. +}
  20751. +
  20752. +static void __dect_raw_rcv(struct sk_buff *skb)
  20753. +{
  20754. + struct dect_cell *cell = DECT_TRX_CB(skb)->trx->cell;
  20755. + struct sk_buff *skb2;
  20756. + struct sock *sk;
  20757. +
  20758. + sk_for_each_bound(sk, &dect_raw_sockets) {
  20759. + if (sk->sk_bound_dev_if &&
  20760. + sk->sk_bound_dev_if != cell->index)
  20761. + continue;
  20762. + if (skb->sk == sk)
  20763. + continue;
  20764. +
  20765. + skb2 = skb_clone(skb, GFP_ATOMIC);
  20766. + if (skb2 == NULL) {
  20767. + sk->sk_err = -ENOMEM;
  20768. + sk->sk_error_report(sk);
  20769. + } else {
  20770. + /* Release the transceiver reference, it is only valid
  20771. + * in IRQ and softirq context.
  20772. + */
  20773. + DECT_TRX_CB(skb2)->trx = NULL;
  20774. + if (dect_sock_queue_rcv_skb(sk, skb2) < 0)
  20775. + kfree_skb(skb2);
  20776. + }
  20777. + }
  20778. +}
  20779. +
  20780. +static void dect_raw_close(struct sock *sk, long timeout)
  20781. +{
  20782. + sk_common_release(sk);
  20783. +}
  20784. +
  20785. +static int dect_raw_bind(struct sock *sk, struct sockaddr *uaddr, int len)
  20786. +{
  20787. + struct sockaddr_dect *addr = (struct sockaddr_dect *)uaddr;
  20788. +
  20789. + if (len < sizeof(*addr) || addr->dect_family != AF_DECT)
  20790. + return -EINVAL;
  20791. +
  20792. + if (addr->dect_index != 0 &&
  20793. + !dect_cell_get_by_index(addr->dect_index))
  20794. + return -ENODEV;
  20795. +
  20796. + lock_sock(sk);
  20797. + sk->sk_bound_dev_if = addr->dect_index;
  20798. + if (!hlist_unhashed(&sk->sk_bind_node))
  20799. + __sk_del_bind_node(sk);
  20800. + sk_add_bind_node(sk, &dect_raw_sockets);
  20801. + release_sock(sk);
  20802. + return 0;
  20803. +}
  20804. +
  20805. +static void dect_raw_unhash(struct sock *sk)
  20806. +{
  20807. + if (!hlist_unhashed(&sk->sk_bind_node))
  20808. + __sk_del_bind_node(sk);
  20809. +}
  20810. +
  20811. +static int dect_raw_getname(struct sock *sk, struct sockaddr *uaddr, int *len,
  20812. + int peer)
  20813. +{
  20814. + struct sockaddr_dect *addr = (struct sockaddr_dect *)uaddr;
  20815. +
  20816. + if (peer)
  20817. + return -EOPNOTSUPP;
  20818. +
  20819. + addr->dect_family = AF_DECT;
  20820. + addr->dect_index = sk->sk_bound_dev_if;
  20821. + *len = sizeof(*addr);
  20822. + return 0;
  20823. +}
  20824. +
  20825. +static int dect_raw_recvmsg(struct sock *sk,
  20826. + struct msghdr *msg, size_t len,
  20827. + int noblock, int flags, int *addrlen)
  20828. +{
  20829. + struct sockaddr_dect *addr;
  20830. + struct dect_raw_auxdata aux;
  20831. + struct sk_buff *skb;
  20832. + size_t copied = 0;
  20833. + int err;
  20834. +
  20835. + if (flags & MSG_OOB)
  20836. + return -EOPNOTSUPP;
  20837. +
  20838. + skb = skb_recv_datagram(sk, flags, noblock, &err);
  20839. + if (skb == NULL)
  20840. + goto out;
  20841. +
  20842. + copied = skb->len;
  20843. + if (len < copied) {
  20844. + msg->msg_flags |= MSG_TRUNC;
  20845. + copied = len;
  20846. + }
  20847. +
  20848. + err = skb_copy_datagram_msg(skb, 0, msg, copied);
  20849. + if (err < 0)
  20850. + goto out_free;
  20851. +
  20852. + if (msg->msg_name != NULL) {
  20853. + addr = (struct sockaddr_dect *)msg->msg_name;
  20854. + addr->dect_family = AF_DECT;
  20855. + addr->dect_index = DECT_SK_CB(skb)->index;
  20856. + msg->msg_namelen = sizeof(*addr);
  20857. + }
  20858. +
  20859. + sock_recv_timestamp(msg, sk, skb);
  20860. +
  20861. + aux.mfn = DECT_TRX_CB(skb)->mfn;
  20862. + aux.frame = DECT_TRX_CB(skb)->frame;
  20863. + aux.slot = DECT_TRX_CB(skb)->slot;
  20864. + aux.rssi = DECT_TRX_CB(skb)->rssi;
  20865. + put_cmsg(msg, SOL_DECT, DECT_RAW_AUXDATA, sizeof(aux), &aux);
  20866. +
  20867. + if (flags & MSG_TRUNC)
  20868. + copied = skb->len;
  20869. +out_free:
  20870. + skb_free_datagram(sk, skb);
  20871. +out:
  20872. + return err ? : copied;
  20873. +}
  20874. +
  20875. +static int dect_raw_sendmsg(struct sock *sk,
  20876. + struct msghdr *msg, size_t len)
  20877. +{
  20878. + struct sockaddr_dect *addr = msg->msg_name;
  20879. + struct dect_raw_auxdata *aux = NULL;
  20880. + struct dect_cell *cell;
  20881. + struct sk_buff *skb;
  20882. + struct cmsghdr *cmsg;
  20883. + size_t size;
  20884. + int index;
  20885. + int err;
  20886. +
  20887. + if (msg->msg_namelen) {
  20888. + if (addr->dect_family != AF_DECT)
  20889. + return -EINVAL;
  20890. + index = addr->dect_index;
  20891. + } else
  20892. + index = sk->sk_bound_dev_if;
  20893. +
  20894. + cell = dect_cell_get_by_index(index);
  20895. + if (cell == NULL)
  20896. + return -ENODEV;
  20897. +
  20898. + for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg)) {
  20899. + if (!CMSG_OK(msg, cmsg))
  20900. + return -EINVAL;
  20901. + if (cmsg->cmsg_level != SOL_DECT)
  20902. + continue;
  20903. +
  20904. + switch (cmsg->cmsg_type) {
  20905. + case DECT_RAW_AUXDATA:
  20906. + if (cmsg->cmsg_len != CMSG_LEN(sizeof(*aux)))
  20907. + return -EINVAL;
  20908. + aux = (struct dect_raw_auxdata *)CMSG_DATA(cmsg);
  20909. + break;
  20910. + default:
  20911. + return -EINVAL;
  20912. + }
  20913. + }
  20914. +
  20915. + if (aux == NULL)
  20916. + return -EINVAL;
  20917. +
  20918. + size = DECT_PREAMBLE_SIZE + len;
  20919. + skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, &err);
  20920. + if (skb == NULL)
  20921. + goto err1;
  20922. +
  20923. + /* Reserve space for preamble */
  20924. + skb_reset_mac_header(skb);
  20925. + skb_reserve(skb, DECT_PREAMBLE_SIZE);
  20926. +
  20927. + err = memcpy_from_msg(skb_put(skb, len), msg, len);
  20928. + if (err < 0)
  20929. + goto err2;
  20930. +
  20931. + DECT_TRX_CB(skb)->mfn = aux->mfn;
  20932. + DECT_TRX_CB(skb)->frame = aux->frame;
  20933. + DECT_TRX_CB(skb)->slot = aux->slot;
  20934. +
  20935. + skb_queue_tail(&cell->raw_tx_queue, skb);
  20936. + return len;
  20937. +
  20938. +err2:
  20939. + kfree_skb(skb);
  20940. +err1:
  20941. + return err;
  20942. +}
  20943. +
  20944. +static struct dect_proto dect_raw_proto = {
  20945. + .type = SOCK_RAW,
  20946. + .protocol = DECT_RAW,
  20947. + .capability = CAP_NET_RAW,
  20948. + .ops = &dect_dgram_ops,
  20949. + .proto.name = "DECT_RAW",
  20950. + .proto.owner = THIS_MODULE,
  20951. + .proto.obj_size = sizeof(struct dect_raw_sk),
  20952. + .proto.close = dect_raw_close,
  20953. + .proto.bind = dect_raw_bind,
  20954. + .proto.unhash = dect_raw_unhash,
  20955. + .proto.recvmsg = dect_raw_recvmsg,
  20956. + .proto.sendmsg = dect_raw_sendmsg,
  20957. + .getname = dect_raw_getname,
  20958. +};
  20959. +
  20960. +static int __init dect_raw_init(void)
  20961. +{
  20962. + int err;
  20963. +
  20964. + BUILD_BUG_ON(sizeof(struct sockaddr_dect) >
  20965. + sizeof(struct sockaddr));
  20966. + err = dect_proto_register(&dect_raw_proto);
  20967. + if (err < 0)
  20968. + return err;
  20969. + rcu_assign_pointer(dect_raw_rcv_hook, __dect_raw_rcv);
  20970. + return 0;
  20971. +}
  20972. +
  20973. +static void __exit dect_raw_exit(void)
  20974. +{
  20975. + rcu_assign_pointer(dect_raw_rcv_hook, NULL);
  20976. + synchronize_rcu();
  20977. + dect_proto_unregister(&dect_raw_proto);
  20978. +}
  20979. +
  20980. +module_init(dect_raw_init);
  20981. +module_exit(dect_raw_exit);
  20982. +
  20983. +MODULE_AUTHOR("Patrick McHardy <[email protected]>");
  20984. +MODULE_DESCRIPTION("DECT RAW sockets");
  20985. +MODULE_LICENSE("GPL");
  20986. +
  20987. +MODULE_ALIAS_NET_PF_PROTO(PF_DECT, DECT_RAW);
  20988. diff --git a/net/dect/transceiver.c b/net/dect/transceiver.c
  20989. new file mode 100644
  20990. index 0000000..a4ac3e7
  20991. --- /dev/null
  20992. +++ b/net/dect/transceiver.c
  20993. @@ -0,0 +1,1063 @@
  20994. +/*
  20995. + * DECT transceiver and transceiver group functions
  20996. + *
  20997. + * Copyright (c) 2009 Patrick McHardy <[email protected]>
  20998. + *
  20999. + * This program is free software; you can redistribute it and/or modify
  21000. + * it under the terms of the GNU General Public License version 2 as
  21001. + * published by the Free Software Foundation.
  21002. + */
  21003. +
  21004. +//#define DEBUG
  21005. +#include <linux/kernel.h>
  21006. +#include <linux/module.h>
  21007. +#include <linux/init.h>
  21008. +#include <linux/mutex.h>
  21009. +#include <linux/list.h>
  21010. +#include <linux/notifier.h>
  21011. +#include <net/dect/dect.h>
  21012. +#include <net/dect/mac_csf.h>
  21013. +#include <net/dect/transceiver.h>
  21014. +
  21015. +static LIST_HEAD(dect_transceiver_list);
  21016. +static int dect_transceiver_notify(struct dect_transceiver *trx,
  21017. + unsigned long event);
  21018. +
  21019. +#define trx_debug(trx, fmt, args...) \
  21020. + pr_debug("%s: " fmt, trx->name, ## args)
  21021. +
  21022. +static const struct dect_band *dect_band[DECT_BAND_NUM];
  21023. +static const u8 dect_pkt_size[] = {
  21024. + [DECT_PACKET_P00] = DECT_P00_SIZE,
  21025. + [DECT_PACKET_P08] = DECT_P08_SIZE,
  21026. + [DECT_PACKET_P32] = DECT_P32_SIZE,
  21027. + [DECT_PACKET_P640j] = DECT_P640j_SIZE,
  21028. + [DECT_PACKET_P672j] = DECT_P672j_SIZE,
  21029. + [DECT_PACKET_P80] = DECT_P80_SIZE,
  21030. +};
  21031. +
  21032. +/**
  21033. + * dect_transceiver_alloc_skb - allocate a transceiver RX skb
  21034. + *
  21035. + * @trx: transceiver
  21036. + * @slot: slot number
  21037. + *
  21038. + * Allocate a skb according to the receiving channel characteristics.
  21039. + */
  21040. +struct sk_buff *dect_transceiver_alloc_skb(struct dect_transceiver *trx, u8 slot)
  21041. +{
  21042. + const struct dect_transceiver_slot *ts = &trx->slots[slot];
  21043. + unsigned int align;
  21044. + struct sk_buff *skb;
  21045. +
  21046. + align = __alignof__(u64) - DECT_PREAMBLE_SIZE;
  21047. +
  21048. + skb = alloc_skb(dect_pkt_size[ts->chd.pkt] + align, GFP_ATOMIC);
  21049. + if (skb == NULL)
  21050. + return NULL;
  21051. + DECT_TRX_CB(skb)->trx = trx;
  21052. + DECT_TRX_CB(skb)->slot = ts->chd.slot;
  21053. + /* Reserve room for preamble and set up adjacent packet data pointer */
  21054. + skb_reserve(skb, DECT_PREAMBLE_SIZE + align);
  21055. + skb_put(skb, dect_pkt_size[ts->chd.pkt] - DECT_PREAMBLE_SIZE);
  21056. + return skb;
  21057. +}
  21058. +EXPORT_SYMBOL_GPL(dect_transceiver_alloc_skb);
  21059. +
  21060. +/* Transceiver virtual clock maintenance:
  21061. + *
  21062. + * The transceiver layer processes the received frames from some slots in
  21063. + * the past while the transceiver is transceiving on the following slots.
  21064. + * Additionally the transceiver needs to be maintained for the upcoming
  21065. + * slots. Therefore there are three different reference frames of time:
  21066. + *
  21067. + * [ RX ][ TRX ][ TX ]
  21068. + * slot_0 -> slot_23
  21069. + *
  21070. + * - Real time, which is only known to the transceiver
  21071. + *
  21072. + * - RX time, which is a virtual clock following real time by at least one
  21073. + * slot and advancing as received slots are processed. A transceiver must
  21074. + * generate enough events so that the RX time never lags behind the TRX
  21075. + * time for more than one TDMA half frame.
  21076. + *
  21077. + * - TX time, which is a virtual clock leading RX time by a usually constant
  21078. + * amount of slots large enough so that packets queued to the transceiver
  21079. + * will reach the transceiver in time to be sent. It always leads real time,
  21080. + * but must never have a distance greater than one TDMA half frame from RX
  21081. + * time, resulting in a maximal distance of 11 to real time.
  21082. + *
  21083. + * Transceivers periodically notify the transceiver layer of an elapsed amount
  21084. + * of time and the frames that were received during that period. The events
  21085. + * batches generated by multiple transceivers contained in a group are merged
  21086. + * and processed as a single chronological event stream.
  21087. + *
  21088. + * The following steps are performed during processing (for every slot):
  21089. + *
  21090. + * - Received packets are passed to the MAC layer
  21091. + * - A RX tick is generated, ending the last RX slot
  21092. + * - A TX tick with some offset in the future is generated, beginning the
  21093. + * next TX slot
  21094. + *
  21095. + * The RX and TX ticks are used by the MAC layer to maintain two timer bases
  21096. + * for performing maintenance operations after a slot was received or before
  21097. + * a slot will be transmitted.
  21098. + */
  21099. +
  21100. +/**
  21101. + * dect_transceiver_queue_event - queue a transceiver event for BH processing
  21102. + *
  21103. + * @trx: DECT transceiver
  21104. + * @event: Transceiver event
  21105. + */
  21106. +void dect_transceiver_queue_event(struct dect_transceiver *trx,
  21107. + struct dect_transceiver_event *event)
  21108. +{
  21109. + struct dect_transceiver_group *grp = &trx->cell->trg;
  21110. +
  21111. + spin_lock(&grp->lock);
  21112. + list_add_tail(&event->list, &grp->events);
  21113. + spin_unlock(&grp->lock);
  21114. +
  21115. + tasklet_hi_schedule(&grp->tasklet);
  21116. +}
  21117. +EXPORT_SYMBOL_GPL(dect_transceiver_queue_event);
  21118. +
  21119. +static struct dect_transceiver_event *
  21120. +dect_dequeue_event(struct dect_transceiver_group *grp)
  21121. +{
  21122. + struct dect_transceiver_event *event;
  21123. + unsigned long flags;
  21124. +
  21125. + event = NULL;
  21126. + spin_lock_irqsave(&grp->lock, flags);
  21127. + if (!list_empty(&grp->events)) {
  21128. + event = list_first_entry(&grp->events,
  21129. + struct dect_transceiver_event,
  21130. + list);
  21131. + list_del(&event->list);
  21132. + }
  21133. + spin_unlock_irqrestore(&grp->lock, flags);
  21134. + return event;
  21135. +}
  21136. +
  21137. +static void dect_tg_merge_events(struct dect_transceiver_group *grp,
  21138. + struct dect_transceiver *trx,
  21139. + struct dect_transceiver_event *event)
  21140. +{
  21141. + struct sk_buff *skb;
  21142. + u8 slot, idx, i;
  21143. +
  21144. + /* Transfer the packets to the slot input queues and mark the
  21145. + * slot events.
  21146. + */
  21147. + trx_debug(trx, "merge %u events pos %u rssi_mask %x\n",
  21148. + trx->ops->eventrate, event->slotpos, event->rssi_mask);
  21149. +
  21150. + for (i = 0; i < trx->ops->eventrate; i++) {
  21151. + slot = event->slotpos + i;
  21152. + idx = slot % ARRAY_SIZE(grp->slots);
  21153. +
  21154. + skb = skb_peek(&event->rx_queue);
  21155. + if (skb != NULL && DECT_TRX_CB(skb)->slot == slot) {
  21156. + __skb_unlink(skb, &event->rx_queue);
  21157. + __skb_queue_tail(&grp->slots[idx].queue, skb);
  21158. + } else if (event->rssi_mask & (1 << i))
  21159. + grp->slots[idx].rssi[trx->index] = event->rssi[i];
  21160. +
  21161. + grp->slots[idx].mask |= 1 << trx->index;
  21162. + }
  21163. +}
  21164. +
  21165. +static bool seqno_before(u32 seq1, u32 seq2)
  21166. +{
  21167. + return (s32)(seq2 - seq1) > 0;
  21168. +}
  21169. +
  21170. +static bool seqno_after(u32 seq1, u32 seq2)
  21171. +{
  21172. + return seqno_before(seq2, seq1);
  21173. +}
  21174. +
  21175. +static void dect_tg_process_events(struct dect_transceiver_group *grp)
  21176. +{
  21177. + struct dect_transceiver *trx;
  21178. + struct dect_transceiver_slot *ts;
  21179. + struct sk_buff *skb;
  21180. + u8 idx, d, i;
  21181. + u16 late;
  21182. +
  21183. + pr_debug("process events slot_low=%u slot_high=%u distance=%u\n",
  21184. + grp->slot_low, grp->slot_high,
  21185. + dect_slot_distance(grp->slot_low, grp->slot_high));
  21186. +
  21187. + while (grp->slot_low != grp->slot_high) {
  21188. + /*
  21189. + * If more than one half frame is missing, only forward the
  21190. + * clock since the slot positions refer to slots in the
  21191. + * following half frame.
  21192. + */
  21193. + d = dect_slot_distance(grp->slot_low, grp->slot_high);
  21194. + if (d > ARRAY_SIZE(grp->slots))
  21195. + goto tick;
  21196. +
  21197. + idx = grp->slot_low % ARRAY_SIZE(grp->slots);
  21198. +
  21199. + /* Check for transceivers which are lagging by more than their
  21200. + * event rate window and mark the current window entirely as
  21201. + * lost.
  21202. + */
  21203. + late = grp->slots[idx].mask ^ grp->trxmask;
  21204. + while (late != 0) {
  21205. + trx = grp->trx[ffs(late) - 1];
  21206. + late &= ~(1 << trx->index);
  21207. +
  21208. + if (!seqno_before(trx->seqno + trx->ops->eventrate,
  21209. + grp->seqno) &&
  21210. + d <= trx->ops->eventrate)
  21211. + continue;
  21212. +
  21213. + trx_debug(trx, "late for window %u\n", grp->slot_low);
  21214. + for (i = 0; i < trx->ops->eventrate; i++)
  21215. + grp->slots[(idx + i) % 12].mask |= 1 << trx->index;
  21216. + trx->stats.event_late++;
  21217. + }
  21218. +
  21219. + if (grp->slots[idx].mask != grp->trxmask) {
  21220. + pr_debug("slot %u incomplete: mask %x trx %x\n",
  21221. + grp->slot_low, grp->slots[idx].mask, grp->trxmask);
  21222. + break;
  21223. + }
  21224. +
  21225. + while ((skb = __skb_dequeue(&grp->slots[idx].queue))) {
  21226. + trx = DECT_TRX_CB(skb)->trx;
  21227. + ts = &trx->slots[DECT_TRX_CB(skb)->slot];
  21228. + dect_mac_rcv(trx, ts, skb);
  21229. + }
  21230. +
  21231. + for (i = 0; i < ARRAY_SIZE(grp->slots[idx].rssi); i++) {
  21232. + if (grp->slots[idx].rssi[i] == 0)
  21233. + continue;
  21234. + trx = grp->trx[i];
  21235. + ts = &trx->slots[grp->slot_low];
  21236. + dect_mac_report_rssi(trx, ts, grp->slots[idx].rssi[i]);
  21237. + grp->slots[idx].rssi[i] = 0;
  21238. + }
  21239. +
  21240. + grp->slots[idx].mask = 0;
  21241. +tick:
  21242. + dect_mac_rx_tick(grp, dect_next_slotnum(grp->slot_low));
  21243. + dect_mac_tx_tick(grp, dect_slot_add(grp->slot_low,
  21244. + 2 * grp->latency));
  21245. +
  21246. + grp->slot_low = dect_next_slotnum(grp->slot_low);
  21247. + }
  21248. +}
  21249. +
  21250. +/*
  21251. + * Softirq transceiver group event processing
  21252. + */
  21253. +static void dect_transceiver_tasklet(unsigned long data)
  21254. +{
  21255. + struct dect_transceiver_group *grp = (struct dect_transceiver_group *)data;
  21256. + struct dect_transceiver *trx;
  21257. + struct dect_transceiver_event *event;
  21258. + struct sk_buff *skb;
  21259. +
  21260. +again:
  21261. + event = dect_dequeue_event(grp);
  21262. + if (event == NULL) {
  21263. + dect_tg_process_events(grp);
  21264. + return;
  21265. + }
  21266. +
  21267. + trx = event->trx;
  21268. +
  21269. + trx_debug(trx, "event handler: trx: seq %u pos %u grp: seq %u pos %u\n",
  21270. + trx->seqno, event->slotpos, grp->seqno, grp->slot_low);
  21271. +
  21272. + /* Before a transceiver is locked, its timing might vary and isn't
  21273. + * synchronized to the remaining group. The MAC layer handles this
  21274. + * manually.
  21275. + */
  21276. + if (trx->state != DECT_TRANSCEIVER_LOCKED) {
  21277. + skb = __skb_dequeue(&event->rx_queue);
  21278. + if (skb != NULL)
  21279. + dect_mac_irc_rcv(trx, skb);
  21280. + dect_mac_irc_tick(trx);
  21281. + goto out;
  21282. + }
  21283. +
  21284. + /* If a secondary transceiver enters locked state or a tranceiver missed
  21285. + * a previous window, its sequence number is out of sync. Resync it once
  21286. + * it starts reporting events in the current window.
  21287. + *
  21288. + * FIXME: driver should ignore frames with missed interrupts completely
  21289. + */
  21290. + if (seqno_before(trx->seqno + trx->ops->eventrate, grp->seqno)) {
  21291. + if (event->slotpos != grp->slot_low) {
  21292. + trx_debug(trx, "unsynchronized\n");
  21293. + __skb_queue_purge(&event->rx_queue);
  21294. + goto out;
  21295. + }
  21296. +
  21297. + trx->seqno = grp->seqno;
  21298. + if (grp->slot_high != grp->slot_low)
  21299. + trx->seqno -= trx->ops->eventrate;
  21300. +
  21301. + trx_debug(trx, "synchronized to seqno %u\n", trx->seqno);
  21302. + }
  21303. +
  21304. + /* Merge the events and update the sequence number. The transceiver
  21305. + * with the highest sequence number determines the slot position for
  21306. + * the entire group.
  21307. + */
  21308. + dect_tg_merge_events(grp, trx, event);
  21309. +
  21310. + trx->seqno += trx->ops->eventrate;
  21311. + if (seqno_after(trx->seqno, grp->seqno)) {
  21312. + grp->seqno = trx->seqno;
  21313. + grp->slot_high =
  21314. + dect_slot_add(event->slotpos, trx->ops->eventrate);
  21315. + }
  21316. +
  21317. +out:
  21318. + dect_release_transceiver_event(event);
  21319. + goto again;
  21320. +}
  21321. +
  21322. +static void dect_transceiver_group_compute_features(struct dect_transceiver_group *grp)
  21323. +{
  21324. + struct dect_transceiver *trx;
  21325. + u32 features;
  21326. +
  21327. + features = ~0;
  21328. + dect_foreach_transceiver(trx, grp)
  21329. + features &= trx->ops->features;
  21330. + grp->features = features;
  21331. +}
  21332. +
  21333. +int dect_transceiver_group_add(struct dect_transceiver_group *grp,
  21334. + struct dect_transceiver *trx)
  21335. +{
  21336. + u8 index;
  21337. +
  21338. + index = ffz(grp->trxmask);
  21339. + if (index >= ARRAY_SIZE(grp->trx))
  21340. + return -EMFILE;
  21341. +
  21342. + trx->index = index;
  21343. + grp->trx[index] = trx;
  21344. + if (trx->ops->latency > grp->latency)
  21345. + grp->latency = trx->ops->latency;
  21346. +
  21347. + grp->trxmask |= 1 << index;
  21348. +
  21349. + dect_transceiver_group_compute_features(grp);
  21350. + return 0;
  21351. +}
  21352. +
  21353. +void dect_transceiver_group_remove(struct dect_transceiver_group *grp,
  21354. + struct dect_transceiver *trx)
  21355. +{
  21356. + grp->trxmask &= ~(1 << trx->index);
  21357. + /* Synchronize with interrupt and softirq processing */
  21358. + synchronize_rcu();
  21359. + grp->trx[trx->index] = NULL;
  21360. +
  21361. + dect_transceiver_group_compute_features(grp);
  21362. +}
  21363. +
  21364. +void dect_transceiver_group_init(struct dect_transceiver_group *grp)
  21365. +{
  21366. + unsigned int i;
  21367. +
  21368. + spin_lock_init(&grp->lock);
  21369. + INIT_LIST_HEAD(&grp->events);
  21370. + for (i = 0; i < ARRAY_SIZE(grp->slots); i++)
  21371. + __skb_queue_head_init(&grp->slots[i].queue);
  21372. +
  21373. + tasklet_init(&grp->tasklet, dect_transceiver_tasklet,
  21374. + (unsigned long)grp);
  21375. +}
  21376. +
  21377. +void dect_transceiver_disable(struct dect_transceiver *trx)
  21378. +{
  21379. + trx->ops->disable(trx);
  21380. + trx->state = DECT_TRANSCEIVER_STOPPED;
  21381. +}
  21382. +
  21383. +void dect_transceiver_enable(struct dect_transceiver *trx)
  21384. +{
  21385. + if (trx->mode == DECT_TRANSCEIVER_MASTER)
  21386. + trx->state = DECT_TRANSCEIVER_LOCKED;
  21387. + else
  21388. + trx->state = DECT_TRANSCEIVER_UNLOCKED;
  21389. +
  21390. + trx->ops->enable(trx);
  21391. +}
  21392. +
  21393. +void dect_transceiver_confirm(struct dect_transceiver *trx)
  21394. +{
  21395. + trx_debug(trx, "confirm\n");
  21396. + trx->state = DECT_TRANSCEIVER_LOCK_PENDING;
  21397. + trx->slots[DECT_SCAN_SLOT].state = DECT_SLOT_RX;
  21398. + trx->ops->confirm(trx);
  21399. +}
  21400. +
  21401. +void dect_transceiver_unlock(struct dect_transceiver *trx)
  21402. +{
  21403. + trx_debug(trx, "unlock\n");
  21404. + trx->ops->unlock(trx);
  21405. + trx->slots[DECT_SCAN_SLOT].state = DECT_SLOT_SCANNING;
  21406. + trx->state = DECT_TRANSCEIVER_UNLOCKED;
  21407. +}
  21408. +
  21409. +int dect_transceiver_set_band(struct dect_transceiver *trx, u8 bandnum)
  21410. +{
  21411. + const struct dect_band *band;
  21412. +
  21413. + band = dect_band[bandnum];
  21414. + if (band == NULL)
  21415. + return -ENOENT;
  21416. + trx->carriers = trx->ops->set_band(trx, band);
  21417. + trx->band = band;
  21418. + return 0;
  21419. +}
  21420. +
  21421. +void dect_transceiver_lock(struct dect_transceiver *trx, u8 slot)
  21422. +{
  21423. + trx_debug(trx, "lock to slot %u\n", slot);
  21424. + trx->slots[DECT_SCAN_SLOT].state = DECT_SLOT_IDLE;
  21425. + trx->state = DECT_TRANSCEIVER_LOCKED;
  21426. + trx->ops->lock(trx, slot);
  21427. +}
  21428. +
  21429. +static void dect_transceiver_set_blind(struct dect_transceiver *trx, u8 slot)
  21430. +{
  21431. + u8 n = DECT_FRAME_SIZE - 1 - slot;
  21432. +
  21433. + trx->slots[slot].blinded++;
  21434. + trx->blind_full_slots |= 1 << n;
  21435. +}
  21436. +
  21437. +static void dect_transceiver_set_visible(struct dect_transceiver *trx, u8 slot)
  21438. +{
  21439. + u8 n = DECT_FRAME_SIZE - 1 - slot;
  21440. +
  21441. + if (--trx->slots[slot].blinded == 0)
  21442. + trx->blind_full_slots &= ~(1 << n);
  21443. +}
  21444. +
  21445. +static bool dect_transceiver_slot_blind(const struct dect_transceiver *trx, u8 slot)
  21446. +{
  21447. + u8 n = DECT_FRAME_SIZE - 1 - slot;
  21448. +
  21449. + return trx->blind_full_slots & (1 << n);
  21450. +}
  21451. +
  21452. +bool dect_transceiver_channel_available(const struct dect_transceiver *trx,
  21453. + const struct dect_channel_desc *chd)
  21454. +{
  21455. + u8 slot = chd->slot, prev, next;
  21456. +
  21457. + if (trx->slots[slot].state == DECT_SLOT_RX ||
  21458. + trx->slots[slot].state == DECT_SLOT_TX)
  21459. + return false;
  21460. +
  21461. + switch ((int)chd->pkt) {
  21462. + case DECT_PACKET_P80:
  21463. + case DECT_PACKET_P640j:
  21464. + case DECT_PACKET_P672j:
  21465. + if (dect_transceiver_slot_blind(trx, slot + 1))
  21466. + return false;
  21467. + case DECT_PACKET_P32:
  21468. + case DECT_PACKET_P08:
  21469. + case DECT_PACKET_P00:
  21470. + if (dect_transceiver_slot_blind(trx, slot))
  21471. + return false;
  21472. + break;
  21473. + }
  21474. +
  21475. + /* In case of slow hopping transceivers the adjacent slots must be
  21476. + * available as well. Scanning slots are not blind, so they must be
  21477. + * checked for explicitly.
  21478. + */
  21479. + if (trx->ops->features & DECT_TRANSCEIVER_SLOW_HOPPING) {
  21480. + prev = dect_prev_slotnum(slot);
  21481. + if (trx->slots[prev].state == DECT_SLOT_SCANNING)
  21482. + return false;
  21483. + next = dect_next_slotnum(slot);
  21484. + if (trx->slots[next].state == DECT_SLOT_SCANNING)
  21485. + return false;
  21486. + }
  21487. +
  21488. + return true;
  21489. +}
  21490. +
  21491. +static bool dect_tg_update_blind_full_slots(struct dect_transceiver_group *trg)
  21492. +{
  21493. + const struct dect_transceiver *trx;
  21494. + u32 blind_full_slots;
  21495. +
  21496. + blind_full_slots = (~0U) & DECT_SLOT_MASK;
  21497. + dect_foreach_transceiver(trx, trg)
  21498. + blind_full_slots &= trx->blind_full_slots;
  21499. +
  21500. + if (trg->blind_full_slots != blind_full_slots) {
  21501. + trg->blind_full_slots = blind_full_slots;
  21502. + return true;
  21503. + } else
  21504. + return false;
  21505. +}
  21506. +
  21507. +/**
  21508. + * dect_transceiver_reserve - reserve transceiver resources for a physical channel
  21509. + *
  21510. + * Reserve the slot positions necessary to estabish the specified physical
  21511. + * channel. The chosen transceivers and the global groups blind full slot
  21512. + * masks are updated.
  21513. + *
  21514. + * Returns true when the global visibility state has changed.
  21515. + */
  21516. +bool dect_transceiver_reserve(struct dect_transceiver_group *trg,
  21517. + struct dect_transceiver *trx,
  21518. + const struct dect_channel_desc *chd)
  21519. +{
  21520. + u8 slot = chd->slot;
  21521. +
  21522. + switch ((int)chd->pkt) {
  21523. + case DECT_PACKET_P80:
  21524. + case DECT_PACKET_P640j:
  21525. + case DECT_PACKET_P672j:
  21526. + dect_transceiver_set_blind(trx, slot + 1);
  21527. + case DECT_PACKET_P32:
  21528. + case DECT_PACKET_P08:
  21529. + case DECT_PACKET_P00:
  21530. + dect_transceiver_set_blind(trx, slot);
  21531. + break;
  21532. + }
  21533. +
  21534. + /* Set adjacent slots blind if the transceiver is slow hopping */
  21535. + if (trx->ops->features & DECT_TRANSCEIVER_SLOW_HOPPING) {
  21536. + dect_transceiver_set_blind(trx, dect_prev_slotnum(slot));
  21537. + dect_transceiver_set_blind(trx, dect_next_slotnum(slot));
  21538. + }
  21539. +
  21540. + return dect_tg_update_blind_full_slots(trg);
  21541. +}
  21542. +
  21543. +/**
  21544. + * dect_transceiver_release - release transceiver resources of a phyiscal channel
  21545. + *
  21546. + * Release the slot positions used by the specified physical channel. The
  21547. + * transceiver and the global group blind full slot masks are updated.
  21548. + *
  21549. + * Returns true when the global visibility state has changed.
  21550. + */
  21551. +bool dect_transceiver_release(struct dect_transceiver_group *trg,
  21552. + struct dect_transceiver *trx,
  21553. + const struct dect_channel_desc *chd)
  21554. +{
  21555. + u8 slot = chd->slot;
  21556. +
  21557. + switch ((int)chd->pkt) {
  21558. + case DECT_PACKET_P80:
  21559. + case DECT_PACKET_P640j:
  21560. + case DECT_PACKET_P672j:
  21561. + dect_transceiver_set_visible(trx, slot + 1);
  21562. + case DECT_PACKET_P32:
  21563. + case DECT_PACKET_P08:
  21564. + case DECT_PACKET_P00:
  21565. + dect_transceiver_set_visible(trx, slot);
  21566. + break;
  21567. + }
  21568. +
  21569. + /* Set adjacent slots unblind if the transceiver is slow hopping */
  21570. + if (trx->ops->features & DECT_TRANSCEIVER_SLOW_HOPPING) {
  21571. + dect_transceiver_set_visible(trx, dect_next_slotnum(slot));
  21572. + dect_transceiver_set_visible(trx, dect_prev_slotnum(slot));
  21573. + }
  21574. +
  21575. + return dect_tg_update_blind_full_slots(trg);
  21576. +}
  21577. +
  21578. +struct dect_transceiver *dect_transceiver_alloc(const struct dect_transceiver_ops *ops,
  21579. + unsigned int priv)
  21580. +{
  21581. + struct dect_transceiver *trx;
  21582. + unsigned int nevents, size, i;
  21583. +
  21584. + /* Allocate enough event structures for one TDMA half frame */
  21585. + nevents = DECT_HALF_FRAME_SIZE / ops->eventrate;
  21586. + size = nevents * sizeof(trx->event[0]) + priv;
  21587. +
  21588. + trx = kzalloc(sizeof(*trx) + size, GFP_KERNEL);
  21589. + if (trx == NULL)
  21590. + return NULL;
  21591. +
  21592. + trx->state = DECT_TRANSCEIVER_STOPPED;
  21593. + trx->ops = ops;
  21594. + for (i = 0; i < DECT_FRAME_SIZE; i++)
  21595. + trx->slots[i].chd.slot = i;
  21596. +
  21597. + for (i = 0; i < nevents; i++) {
  21598. + skb_queue_head_init(&trx->event[i].rx_queue);
  21599. + trx->event[i].trx = trx;
  21600. + }
  21601. + return trx;
  21602. +}
  21603. +EXPORT_SYMBOL_GPL(dect_transceiver_alloc);
  21604. +
  21605. +void dect_transceiver_free(struct dect_transceiver *trx)
  21606. +{
  21607. + kfree(trx);
  21608. +}
  21609. +EXPORT_SYMBOL_GPL(dect_transceiver_free);
  21610. +
  21611. +static int dect_transceiver_alloc_name(struct dect_transceiver *trx)
  21612. +{
  21613. + struct dect_transceiver *t;
  21614. + unsigned long *inuse;
  21615. + int i;
  21616. +
  21617. + inuse = (unsigned long *)get_zeroed_page(GFP_KERNEL);
  21618. + if (inuse == NULL)
  21619. + return -ENOMEM;
  21620. +
  21621. + list_for_each_entry(t, &dect_transceiver_list, list) {
  21622. + if (!sscanf(t->name, "trx%d", &i))
  21623. + continue;
  21624. + if (i > BITS_PER_BYTE * PAGE_SIZE)
  21625. + continue;
  21626. + set_bit(i, inuse);
  21627. + }
  21628. +
  21629. + i = find_first_zero_bit(inuse, BITS_PER_BYTE * PAGE_SIZE);
  21630. + free_page((unsigned long)inuse);
  21631. + if (i == BITS_PER_BYTE * PAGE_SIZE)
  21632. + return -ENFILE;
  21633. +
  21634. + snprintf(trx->name, sizeof(trx->name), "trx%d", i);
  21635. + return 0;
  21636. +}
  21637. +
  21638. +int dect_register_transceiver(struct dect_transceiver *trx)
  21639. +{
  21640. + int err;
  21641. +
  21642. + dect_lock();
  21643. + err = dect_transceiver_alloc_name(trx);
  21644. + if (err < 0)
  21645. + goto out;
  21646. +
  21647. + err = dect_transceiver_set_band(trx, DECT_DEFAULT_BAND);
  21648. + if (err < 0)
  21649. + goto out;
  21650. +
  21651. + list_add_tail(&trx->list, &dect_transceiver_list);
  21652. + dect_transceiver_notify(trx, DECT_TRANSCEIVER_REGISTER);
  21653. +out:
  21654. + dect_unlock();
  21655. +
  21656. + return err;
  21657. +}
  21658. +EXPORT_SYMBOL_GPL(dect_register_transceiver);
  21659. +
  21660. +void dect_unregister_transceiver(struct dect_transceiver *trx)
  21661. +{
  21662. + dect_lock();
  21663. + list_del(&trx->list);
  21664. + dect_transceiver_notify(trx, DECT_TRANSCEIVER_UNREGISTER);
  21665. + dect_unlock();
  21666. +
  21667. + synchronize_rcu();
  21668. + trx->ops->destructor(trx);
  21669. +}
  21670. +EXPORT_SYMBOL_GPL(dect_unregister_transceiver);
  21671. +
  21672. +/*
  21673. + * Transceiver netlink interface
  21674. + */
  21675. +
  21676. +static struct dect_transceiver *dect_transceiver_get_by_name(const struct nlattr *nla)
  21677. +{
  21678. + struct dect_transceiver *trx;
  21679. +
  21680. + list_for_each_entry(trx, &dect_transceiver_list, list) {
  21681. + if (!nla_strcmp(nla, trx->name))
  21682. + return trx;
  21683. + }
  21684. + return NULL;
  21685. +}
  21686. +
  21687. +static int dect_fill_slot(struct sk_buff *skb,
  21688. + const struct dect_transceiver *trx, u8 slot)
  21689. +{
  21690. + const struct dect_transceiver_slot *ts = &trx->slots[slot];
  21691. +
  21692. + if (nla_put_u8(skb, DECTA_SLOT_NUM, slot) ||
  21693. + nla_put_u8(skb, DECTA_SLOT_STATE, ts->state) ||
  21694. + nla_put_u32(skb, DECTA_SLOT_FLAGS, ts->flags))
  21695. + goto nla_put_failure;
  21696. +
  21697. + if (ts->state != DECT_SLOT_IDLE) {
  21698. + if (nla_put_u8(skb, DECTA_SLOT_PACKET, ts->chd.pkt) ||
  21699. + nla_put_u8(skb, DECTA_SLOT_CARRIER, ts->chd.carrier) ||
  21700. + nla_put_u32(skb, DECTA_SLOT_FREQUENCY,
  21701. + trx->band->frequency[ts->chd.carrier]))
  21702. + goto nla_put_failure;
  21703. + }
  21704. + if (ts->state == DECT_SLOT_RX) {
  21705. + nla_put_u32(skb, DECTA_SLOT_PHASEOFF, ts->phaseoff);
  21706. + nla_put_u8(skb, DECTA_SLOT_RSSI,
  21707. + ts->rssi >> DECT_RSSI_AVG_SCALE);
  21708. + }
  21709. + if (nla_put_u32(skb, DECTA_SLOT_RX_BYTES, ts->rx_bytes) ||
  21710. + nla_put_u32(skb, DECTA_SLOT_RX_PACKETS, ts->rx_packets) ||
  21711. + nla_put_u32(skb, DECTA_SLOT_RX_A_CRC_ERRORS, ts->rx_a_crc_errors) ||
  21712. + nla_put_u32(skb, DECTA_SLOT_RX_X_CRC_ERRORS, ts->rx_x_crc_errors) ||
  21713. + nla_put_u32(skb, DECTA_SLOT_RX_Z_CRC_ERRORS, ts->rx_z_crc_errors) ||
  21714. + nla_put_u32(skb, DECTA_SLOT_TX_BYTES, ts->tx_bytes) ||
  21715. + nla_put_u32(skb, DECTA_SLOT_TX_PACKETS, ts->tx_packets))
  21716. + goto nla_put_failure;
  21717. +
  21718. + return 0;
  21719. +
  21720. +nla_put_failure:
  21721. + return -1;
  21722. +}
  21723. +
  21724. +static int dect_fill_transceiver(struct sk_buff *skb,
  21725. + const struct dect_transceiver *trx,
  21726. + u16 type, u32 portid, u32 seq, u16 flags)
  21727. +{
  21728. + const struct dect_transceiver_stats *stats = &trx->stats;
  21729. + struct nlattr *nest, *chan;
  21730. + struct nlmsghdr *nlh;
  21731. + struct dectmsg *dm;
  21732. + u8 slot;
  21733. +
  21734. + nlh = nlmsg_put(skb, portid, seq, type, sizeof(*dm), flags);
  21735. + if (nlh == NULL)
  21736. + return -EMSGSIZE;
  21737. +
  21738. + dm = nlmsg_data(nlh);
  21739. +
  21740. + if (nla_put_string(skb, DECTA_TRANSCEIVER_NAME, trx->name) ||
  21741. + nla_put_string(skb, DECTA_TRANSCEIVER_TYPE, trx->ops->name) ||
  21742. + nla_put_u32(skb, DECTA_TRANSCEIVER_FEATURES, trx->ops->features))
  21743. + goto nla_put_failure;
  21744. + if (trx->cell != NULL &&
  21745. + nla_put_u8(skb, DECTA_TRANSCEIVER_LINK, trx->cell->index))
  21746. + goto nla_put_failure;
  21747. +
  21748. + nest = nla_nest_start(skb, DECTA_TRANSCEIVER_STATS);
  21749. + if (nest == NULL)
  21750. + goto nla_put_failure;
  21751. + if (nla_put_u32(skb, DECTA_TRANSCEIVER_STATS_EVENT_BUSY,
  21752. + stats->event_busy) ||
  21753. + nla_put_u32(skb, DECTA_TRANSCEIVER_STATS_EVENT_LATE,
  21754. + stats->event_late))
  21755. + goto nla_put_failure;
  21756. + nla_nest_end(skb, nest);
  21757. +
  21758. + if (nla_put_u8(skb, DECTA_TRANSCEIVER_BAND, trx->band->band))
  21759. + goto nla_put_failure;
  21760. +
  21761. + nest = nla_nest_start(skb, DECTA_TRANSCEIVER_SLOTS);
  21762. + if (nest == NULL)
  21763. + goto nla_put_failure;
  21764. + for (slot = 0; slot < DECT_FRAME_SIZE; slot++) {
  21765. + chan = nla_nest_start(skb, DECTA_LIST_ELEM);
  21766. + if (chan == NULL)
  21767. + goto nla_put_failure;
  21768. + if (dect_fill_slot(skb, trx, slot) < 0)
  21769. + goto nla_put_failure;
  21770. + nla_nest_end(skb, chan);
  21771. + }
  21772. + nla_nest_end(skb, nest);
  21773. +
  21774. + nlmsg_end(skb, nlh);
  21775. + return skb->len;
  21776. +
  21777. +nla_put_failure:
  21778. + nlmsg_cancel(skb, nlh);
  21779. + return -EMSGSIZE;
  21780. +}
  21781. +
  21782. +static const struct nla_policy dect_transceiver_policy[DECTA_TRANSCEIVER_MAX + 1] = {
  21783. + [DECTA_TRANSCEIVER_NAME] = { .type = NLA_STRING, .len = DECTNAMSIZ },
  21784. + [DECTA_TRANSCEIVER_LINK] = { .type = NLA_U8 },
  21785. +};
  21786. +
  21787. +static int dect_new_transceiver(const struct sk_buff *in_skb,
  21788. + const struct nlmsghdr *nlh,
  21789. + const struct nlattr *tb[DECTA_TRANSCEIVER_MAX + 1])
  21790. +{
  21791. + struct dect_transceiver *trx;
  21792. + struct dect_cell *cell;
  21793. + struct dectmsg *dm;
  21794. + int index;
  21795. +
  21796. + dm = nlmsg_data(nlh);
  21797. +
  21798. + if (tb[DECTA_TRANSCEIVER_NAME] == NULL)
  21799. + return -EINVAL;
  21800. +
  21801. + trx = dect_transceiver_get_by_name(tb[DECTA_TRANSCEIVER_NAME]);
  21802. + if (trx == NULL) {
  21803. + if (nlh->nlmsg_flags & NLM_F_CREATE)
  21804. + return -EOPNOTSUPP;
  21805. + return -ENOENT;
  21806. + }
  21807. + if (nlh->nlmsg_flags & NLM_F_EXCL)
  21808. + return -EEXIST;
  21809. +
  21810. + if (tb[DECTA_TRANSCEIVER_LINK] != NULL) {
  21811. + index = nla_get_u8(tb[DECTA_TRANSCEIVER_LINK]);
  21812. + if (index == -1)
  21813. + dect_cell_detach_transceiver(trx->cell, trx);
  21814. + else {
  21815. + cell = dect_cell_get_by_index(index);
  21816. + if (cell == NULL)
  21817. + return -ENOENT;
  21818. + return dect_cell_attach_transceiver(cell, trx);
  21819. + }
  21820. + }
  21821. + return 0;
  21822. +}
  21823. +
  21824. +static int dect_get_transceiver(const struct sk_buff *in_skb,
  21825. + const struct nlmsghdr *nlh,
  21826. + const struct nlattr *tb[DECTA_TRANSCEIVER_MAX + 1])
  21827. +{
  21828. + u32 portid = NETLINK_CB(in_skb).portid;
  21829. + const struct dect_transceiver *trx;
  21830. + struct sk_buff *skb;
  21831. + int err;
  21832. +
  21833. + if (tb[DECTA_TRANSCEIVER_NAME] == NULL)
  21834. + return -EINVAL;
  21835. +
  21836. + trx = dect_transceiver_get_by_name(tb[DECTA_TRANSCEIVER_NAME]);
  21837. + if (trx == NULL)
  21838. + return -ENOENT;
  21839. +
  21840. + skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
  21841. + if (skb == NULL)
  21842. + return -ENOMEM;
  21843. + err = dect_fill_transceiver(skb, trx, DECT_NEW_TRANSCEIVER, portid,
  21844. + nlh->nlmsg_seq, NLMSG_DONE);
  21845. + if (err < 0)
  21846. + goto err1;
  21847. + return nlmsg_unicast(dect_nlsk, skb, portid);
  21848. +
  21849. +err1:
  21850. + kfree_skb(skb);
  21851. + return err;
  21852. +}
  21853. +
  21854. +static int dect_dump_transceiver(struct sk_buff *skb,
  21855. + struct netlink_callback *cb)
  21856. +{
  21857. + const struct dect_transceiver *trx;
  21858. + unsigned int idx, s_idx;
  21859. +
  21860. + s_idx = cb->args[0];
  21861. + idx = 0;
  21862. + list_for_each_entry(trx, &dect_transceiver_list, list) {
  21863. + if (idx < s_idx)
  21864. + goto cont;
  21865. + if (dect_fill_transceiver(skb, trx, DECT_NEW_TRANSCEIVER,
  21866. + NETLINK_CB(cb->skb).portid,
  21867. + cb->nlh->nlmsg_seq, NLM_F_MULTI) <= 0)
  21868. + break;
  21869. +cont:
  21870. + idx++;
  21871. + }
  21872. + cb->args[0] = idx;
  21873. +
  21874. + return skb->len;
  21875. +}
  21876. +
  21877. +static void dect_notify_transceiver(u16 event, const struct dect_transceiver *trx,
  21878. + const struct nlmsghdr *nlh, u32 portid)
  21879. +{
  21880. + struct sk_buff *skb;
  21881. + bool report = nlh ? nlmsg_report(nlh) : 0;
  21882. + u32 seq = nlh ? nlh->nlmsg_seq : 0;
  21883. + int err = -ENOBUFS;
  21884. +
  21885. + skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
  21886. + if (skb == NULL)
  21887. + goto err;
  21888. +
  21889. + err = dect_fill_transceiver(skb, trx, event, portid, seq, NLMSG_DONE);
  21890. + if (err < 0) {
  21891. + WARN_ON(err == -EMSGSIZE);
  21892. + kfree_skb(skb);
  21893. + goto err;
  21894. + }
  21895. + nlmsg_notify(dect_nlsk, skb, portid, DECTNLGRP_TRANSCEIVER, report,
  21896. + GFP_KERNEL);
  21897. +err:
  21898. + if (err < 0)
  21899. + netlink_set_err(dect_nlsk, portid, DECTNLGRP_TRANSCEIVER, err);
  21900. +}
  21901. +
  21902. +static int dect_transceiver_notify(struct dect_transceiver *trx,
  21903. + unsigned long event)
  21904. +{
  21905. + struct dect_cell *cell = trx->cell;
  21906. +
  21907. + switch (event) {
  21908. + case DECT_TRANSCEIVER_REGISTER:
  21909. + dect_notify_transceiver(DECT_NEW_TRANSCEIVER, trx, NULL, 0);
  21910. + break;
  21911. + case DECT_TRANSCEIVER_UNREGISTER:
  21912. + if (cell != NULL)
  21913. + dect_cell_detach_transceiver(cell, trx);
  21914. + dect_notify_transceiver(DECT_DEL_TRANSCEIVER, trx, NULL, 0);
  21915. + break;
  21916. + }
  21917. + return 0;
  21918. +};
  21919. +
  21920. +
  21921. +static const struct dect_netlink_handler dect_transceiver_handlers[] = {
  21922. + {
  21923. + /* DECT_NEW_TRANSCEIVER */
  21924. + .policy = dect_transceiver_policy,
  21925. + .maxtype = DECTA_TRANSCEIVER_MAX,
  21926. + .doit = dect_new_transceiver,
  21927. + },
  21928. + {
  21929. + /* DECT_DEL_TRANSCEIVER */
  21930. + },
  21931. + {
  21932. + /* DECT_GET_TRANSCEIVER */
  21933. + .policy = dect_transceiver_policy,
  21934. + .maxtype = DECTA_TRANSCEIVER_MAX,
  21935. + .doit = dect_get_transceiver,
  21936. + .dump = dect_dump_transceiver,
  21937. + },
  21938. +};
  21939. +
  21940. +/*
  21941. + * RF-bands:
  21942. + */
  21943. +
  21944. +struct dect_band_desc {
  21945. + u8 band;
  21946. + u8 carriers;
  21947. + s16 c1_off;
  21948. + u8 c2;
  21949. + s16 c2_off;
  21950. +};
  21951. +
  21952. +static const struct dect_band_desc dect_band_desc[] __initdata = {
  21953. + /* 1880 MHz to 1900 MHz RF band 00000 */
  21954. + { 0, 10, 0, -1, 0, },
  21955. + /* 1880 MHz to 1978 MHz and 2010 MHz to 2025 MHz RF band 00001 */
  21956. + { 1, 64, 0, 56, 19, },
  21957. + /* 1880 MHz to 1925 MHz and 2010 MHz to 2025 MHz RF band 00010 */
  21958. + { 2, 33, 0, 25, 50, },
  21959. + /* 1880 MHz to 1900 MHz, 1915 MHz to 1940 MHz and 2010 MHz to
  21960. + * 2025 MHz RF band 00011 */
  21961. + { 3, 33, 10, 25, 50, },
  21962. + /* 1880 MHz to 1900 MHz, 1935 MHz to 1960 MHz and 2010 MHz to
  21963. + * 2025 MHz RF band 00100 */
  21964. + { 4, 33, 22, 25, 50, },
  21965. + /* 1880 MHz to 1900 MHZ, 1955 MHz to 1980 MHz and 2010 MHz to
  21966. + * 2025 MHz RF band 00101 */
  21967. + { 5, 33, 34, 25, 50, },
  21968. + /* 902 MHz to 928 MHz RF band 01000 */
  21969. + { 8, 24, -576, -1, 0, },
  21970. + /* 2400 MHz to 2483,5 MHz RF band 01001 */
  21971. + { 9, 55, 292, -1, 0, },
  21972. +};
  21973. +
  21974. +/*
  21975. + * A nominal DECT RF carrier is one whose center frequency is generated by
  21976. + * the formula:
  21977. + *
  21978. + * Fg = F0 - g \D7 1,728 MHz, where g is any integer
  21979. + */
  21980. +static u32 __init dect_calc_frequency(s16 g)
  21981. +{
  21982. + if (g >= 0 && g < 10)
  21983. + return DECT_FREQUENCY_F0 - g * DECT_CARRIER_WIDTH;
  21984. + else
  21985. + return DECT_FREQUENCY_F0 + (g - 9) * DECT_CARRIER_WIDTH;
  21986. +}
  21987. +
  21988. +static int __init dect_init_band(const struct dect_band_desc *desc)
  21989. +{
  21990. + struct dect_band *band;
  21991. + unsigned int size;
  21992. + u8 carrier;
  21993. +
  21994. + size = sizeof(*band) + desc->carriers * sizeof(band->frequency[0]);
  21995. + band = kmalloc(size, GFP_KERNEL);
  21996. + if (band == NULL)
  21997. + return -ENOMEM;
  21998. +
  21999. + band->band = desc->band;
  22000. + band->carriers = desc->carriers;
  22001. +
  22002. + for (carrier = 0; carrier < 10; carrier++)
  22003. + band->frequency[carrier] =
  22004. + dect_calc_frequency(carrier);
  22005. +
  22006. + for (; carrier < min(desc->carriers, desc->c2); carrier++)
  22007. + band->frequency[carrier] =
  22008. + dect_calc_frequency(carrier + desc->c1_off);
  22009. +
  22010. + for (; carrier < desc->carriers; carrier++)
  22011. + band->frequency[carrier] =
  22012. + dect_calc_frequency(carrier + desc->c2_off);
  22013. +
  22014. + printk("RF-band %u:\n", band->band);
  22015. + for (carrier = 0; carrier < band->carriers; carrier++) {
  22016. + printk(" carrier %u: %u.%03uMHz\n", carrier,
  22017. + band->frequency[carrier] / 1000,
  22018. + band->frequency[carrier] % 1000);
  22019. + }
  22020. + printk("\n");
  22021. +
  22022. + dect_band[band->band] = band;
  22023. + return 0;
  22024. +}
  22025. +
  22026. +int __init dect_transceiver_module_init(void)
  22027. +{
  22028. + unsigned int i;
  22029. + int err;
  22030. +
  22031. + for (i = 0; i < ARRAY_SIZE(dect_band_desc); i++) {
  22032. + err = dect_init_band(&dect_band_desc[i]);
  22033. + if (err < 0)
  22034. + goto err1;
  22035. + }
  22036. +
  22037. + dect_netlink_register_handlers(dect_transceiver_handlers,
  22038. + DECT_NEW_TRANSCEIVER,
  22039. + ARRAY_SIZE(dect_transceiver_handlers));
  22040. + return 0;
  22041. +
  22042. +err1:
  22043. + dect_transceiver_module_exit();
  22044. + return err;
  22045. +}
  22046. +
  22047. +void dect_transceiver_module_exit(void)
  22048. +{
  22049. + u8 band;
  22050. +
  22051. + dect_netlink_unregister_handlers(DECT_NEW_TRANSCEIVER,
  22052. + ARRAY_SIZE(dect_transceiver_handlers));
  22053. +
  22054. + for (band = 0; band < ARRAY_SIZE(dect_band); band++)
  22055. + kfree(dect_band[band]);
  22056. +}