1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <net/nfc/hci.h>
18
19#include "st21nfca.h"
20#include "st21nfca_dep.h"
21
22#define ST21NFCA_NFCIP1_INITIATOR 0x00
23#define ST21NFCA_NFCIP1_REQ 0xd4
24#define ST21NFCA_NFCIP1_RES 0xd5
25#define ST21NFCA_NFCIP1_ATR_REQ 0x00
26#define ST21NFCA_NFCIP1_ATR_RES 0x01
27#define ST21NFCA_NFCIP1_PSL_REQ 0x04
28#define ST21NFCA_NFCIP1_PSL_RES 0x05
29#define ST21NFCA_NFCIP1_DEP_REQ 0x06
30#define ST21NFCA_NFCIP1_DEP_RES 0x07
31
32#define ST21NFCA_NFC_DEP_PFB_PNI(pfb) ((pfb) & 0x03)
33#define ST21NFCA_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
34#define ST21NFCA_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
35 ((pfb) & ST21NFCA_NFC_DEP_PFB_TIMEOUT_BIT)
36#define ST21NFCA_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & 0x04)
37#define ST21NFCA_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)
38#define ST21NFCA_NFC_DEP_PFB_TIMEOUT_BIT 0x10
39
40#define ST21NFCA_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
41 ((pfb) & ST21NFCA_NFC_DEP_PFB_TIMEOUT_BIT)
42
43#define ST21NFCA_NFC_DEP_PFB_I_PDU 0x00
44#define ST21NFCA_NFC_DEP_PFB_ACK_NACK_PDU 0x40
45#define ST21NFCA_NFC_DEP_PFB_SUPERVISOR_PDU 0x80
46
47#define ST21NFCA_ATR_REQ_MIN_SIZE 17
48#define ST21NFCA_ATR_REQ_MAX_SIZE 65
49#define ST21NFCA_LR_BITS_PAYLOAD_SIZE_254B 0x30
50#define ST21NFCA_GB_BIT 0x02
51
52#define ST21NFCA_EVT_CARD_F_BITRATE 0x16
53#define ST21NFCA_EVT_READER_F_BITRATE 0x13
54#define ST21NFCA_PSL_REQ_SEND_SPEED(brs) (brs & 0x38)
55#define ST21NFCA_PSL_REQ_RECV_SPEED(brs) (brs & 0x07)
56#define ST21NFCA_PP2LRI(pp) ((pp & 0x30) >> 4)
57#define ST21NFCA_CARD_BITRATE_212 0x01
58#define ST21NFCA_CARD_BITRATE_424 0x02
59
60#define ST21NFCA_DEFAULT_TIMEOUT 0x0a
61
62
63#define PROTOCOL_ERR(req) pr_err("%d: ST21NFCA Protocol error: %s\n", \
64 __LINE__, req)
65
66struct st21nfca_atr_req {
67 u8 length;
68 u8 cmd0;
69 u8 cmd1;
70 u8 nfcid3[NFC_NFCID3_MAXSIZE];
71 u8 did;
72 u8 bsi;
73 u8 bri;
74 u8 ppi;
75 u8 gbi[0];
76} __packed;
77
78struct st21nfca_atr_res {
79 u8 length;
80 u8 cmd0;
81 u8 cmd1;
82 u8 nfcid3[NFC_NFCID3_MAXSIZE];
83 u8 did;
84 u8 bsi;
85 u8 bri;
86 u8 to;
87 u8 ppi;
88 u8 gbi[0];
89} __packed;
90
91struct st21nfca_psl_req {
92 u8 length;
93 u8 cmd0;
94 u8 cmd1;
95 u8 did;
96 u8 brs;
97 u8 fsl;
98} __packed;
99
100struct st21nfca_psl_res {
101 u8 length;
102 u8 cmd0;
103 u8 cmd1;
104 u8 did;
105} __packed;
106
107struct st21nfca_dep_req_res {
108 u8 length;
109 u8 cmd0;
110 u8 cmd1;
111 u8 pfb;
112 u8 did;
113 u8 nad;
114} __packed;
115
116static void st21nfca_tx_work(struct work_struct *work)
117{
118 struct st21nfca_hci_info *info = container_of(work,
119 struct st21nfca_hci_info,
120 dep_info.tx_work);
121
122 struct nfc_dev *dev;
123 struct sk_buff *skb;
124 if (info) {
125 dev = info->hdev->ndev;
126 skb = info->dep_info.tx_pending;
127
128 device_lock(&dev->dev);
129
130 nfc_hci_send_cmd_async(info->hdev, ST21NFCA_RF_READER_F_GATE,
131 ST21NFCA_WR_XCHG_DATA,
132 skb->data, skb->len,
133 info->async_cb, info);
134 device_unlock(&dev->dev);
135 kfree_skb(skb);
136 }
137}
138
139static void st21nfca_im_send_pdu(struct st21nfca_hci_info *info,
140 struct sk_buff *skb)
141{
142 info->dep_info.tx_pending = skb;
143 schedule_work(&info->dep_info.tx_work);
144}
145
146static int st21nfca_tm_send_atr_res(struct nfc_hci_dev *hdev,
147 struct st21nfca_atr_req *atr_req)
148{
149 struct st21nfca_atr_res *atr_res;
150 struct sk_buff *skb;
151 size_t gb_len;
152 int r;
153 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
154
155 gb_len = atr_req->length - sizeof(struct st21nfca_atr_req);
156 skb = alloc_skb(atr_req->length + 1, GFP_KERNEL);
157 if (!skb)
158 return -ENOMEM;
159
160 skb_put(skb, sizeof(struct st21nfca_atr_res));
161
162 atr_res = (struct st21nfca_atr_res *)skb->data;
163 memset(atr_res, 0, sizeof(struct st21nfca_atr_res));
164
165 atr_res->length = atr_req->length + 1;
166 atr_res->cmd0 = ST21NFCA_NFCIP1_RES;
167 atr_res->cmd1 = ST21NFCA_NFCIP1_ATR_RES;
168
169 memcpy(atr_res->nfcid3, atr_req->nfcid3, 6);
170 atr_res->bsi = 0x00;
171 atr_res->bri = 0x00;
172 atr_res->to = ST21NFCA_DEFAULT_TIMEOUT;
173 atr_res->ppi = ST21NFCA_LR_BITS_PAYLOAD_SIZE_254B;
174
175 if (gb_len) {
176 skb_put(skb, gb_len);
177
178 atr_res->ppi |= ST21NFCA_GB_BIT;
179 memcpy(atr_res->gbi, atr_req->gbi, gb_len);
180 r = nfc_set_remote_general_bytes(hdev->ndev, atr_res->gbi,
181 gb_len);
182 if (r < 0)
183 return r;
184 }
185
186 info->dep_info.curr_nfc_dep_pni = 0;
187
188 return nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
189 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len);
190}
191
192static int st21nfca_tm_recv_atr_req(struct nfc_hci_dev *hdev,
193 struct sk_buff *skb)
194{
195 struct st21nfca_atr_req *atr_req;
196 size_t gb_len;
197 int r;
198
199 skb_trim(skb, skb->len - 1);
200 if (IS_ERR(skb)) {
201 r = PTR_ERR(skb);
202 goto exit;
203 }
204
205 if (!skb->len) {
206 r = -EIO;
207 goto exit;
208 }
209
210 if (skb->len < ST21NFCA_ATR_REQ_MIN_SIZE) {
211 r = -EPROTO;
212 goto exit;
213 }
214
215 atr_req = (struct st21nfca_atr_req *)skb->data;
216
217 r = st21nfca_tm_send_atr_res(hdev, atr_req);
218 if (r)
219 goto exit;
220
221 gb_len = skb->len - sizeof(struct st21nfca_atr_req);
222
223 r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK,
224 NFC_COMM_PASSIVE, atr_req->gbi, gb_len);
225 if (r)
226 goto exit;
227
228 r = 0;
229
230exit:
231 return r;
232}
233
234static int st21nfca_tm_send_psl_res(struct nfc_hci_dev *hdev,
235 struct st21nfca_psl_req *psl_req)
236{
237 struct st21nfca_psl_res *psl_res;
238 struct sk_buff *skb;
239 u8 bitrate[2] = {0, 0};
240
241 int r;
242
243 skb = alloc_skb(sizeof(struct st21nfca_psl_res), GFP_KERNEL);
244 if (!skb)
245 return -ENOMEM;
246 skb_put(skb, sizeof(struct st21nfca_psl_res));
247
248 psl_res = (struct st21nfca_psl_res *)skb->data;
249
250 psl_res->length = sizeof(struct st21nfca_psl_res);
251 psl_res->cmd0 = ST21NFCA_NFCIP1_RES;
252 psl_res->cmd1 = ST21NFCA_NFCIP1_PSL_RES;
253 psl_res->did = psl_req->did;
254
255 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
256 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len);
257
258
259
260
261
262
263
264
265 if (ST21NFCA_PSL_REQ_SEND_SPEED(psl_req->brs) &&
266 ST21NFCA_PSL_REQ_RECV_SPEED(psl_req->brs)) {
267 bitrate[0] = ST21NFCA_CARD_BITRATE_424;
268 bitrate[1] = ST21NFCA_CARD_BITRATE_424;
269 }
270
271
272 return nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
273 ST21NFCA_EVT_CARD_F_BITRATE, bitrate, 2);
274}
275
276static int st21nfca_tm_recv_psl_req(struct nfc_hci_dev *hdev,
277 struct sk_buff *skb)
278{
279 struct st21nfca_psl_req *psl_req;
280 int r;
281
282 skb_trim(skb, skb->len - 1);
283 if (IS_ERR(skb)) {
284 r = PTR_ERR(skb);
285 skb = NULL;
286 goto exit;
287 }
288
289 if (!skb->len) {
290 r = -EIO;
291 goto exit;
292 }
293
294 psl_req = (struct st21nfca_psl_req *)skb->data;
295
296 if (skb->len < sizeof(struct st21nfca_psl_req)) {
297 r = -EIO;
298 goto exit;
299 }
300
301 r = st21nfca_tm_send_psl_res(hdev, psl_req);
302exit:
303 return r;
304}
305
306int st21nfca_tm_send_dep_res(struct nfc_hci_dev *hdev, struct sk_buff *skb)
307{
308 int r;
309 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
310
311 *skb_push(skb, 1) = info->dep_info.curr_nfc_dep_pni;
312 *skb_push(skb, 1) = ST21NFCA_NFCIP1_DEP_RES;
313 *skb_push(skb, 1) = ST21NFCA_NFCIP1_RES;
314 *skb_push(skb, 1) = skb->len;
315
316 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
317 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len);
318 kfree_skb(skb);
319
320 return r;
321}
322EXPORT_SYMBOL(st21nfca_tm_send_dep_res);
323
324static int st21nfca_tm_recv_dep_req(struct nfc_hci_dev *hdev,
325 struct sk_buff *skb)
326{
327 struct st21nfca_dep_req_res *dep_req;
328 u8 size;
329 int r;
330 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
331
332 skb_trim(skb, skb->len - 1);
333 if (IS_ERR(skb)) {
334 r = PTR_ERR(skb);
335 skb = NULL;
336 goto exit;
337 }
338
339 size = 4;
340
341 dep_req = (struct st21nfca_dep_req_res *)skb->data;
342 if (skb->len < size) {
343 r = -EIO;
344 goto exit;
345 }
346
347 if (ST21NFCA_NFC_DEP_DID_BIT_SET(dep_req->pfb))
348 size++;
349 if (ST21NFCA_NFC_DEP_NAD_BIT_SET(dep_req->pfb))
350 size++;
351
352 if (skb->len < size) {
353 r = -EIO;
354 goto exit;
355 }
356
357
358 switch (ST21NFCA_NFC_DEP_PFB_TYPE(dep_req->pfb)) {
359 case ST21NFCA_NFC_DEP_PFB_I_PDU:
360 info->dep_info.curr_nfc_dep_pni =
361 ST21NFCA_NFC_DEP_PFB_PNI(dep_req->pfb);
362 break;
363 case ST21NFCA_NFC_DEP_PFB_ACK_NACK_PDU:
364 pr_err("Received a ACK/NACK PDU\n");
365 break;
366 case ST21NFCA_NFC_DEP_PFB_SUPERVISOR_PDU:
367 pr_err("Received a SUPERVISOR PDU\n");
368 break;
369 }
370
371 if (IS_ERR(skb)) {
372 r = PTR_ERR(skb);
373 skb = NULL;
374 goto exit;
375 }
376
377 skb_pull(skb, size);
378
379 return nfc_tm_data_received(hdev->ndev, skb);
380exit:
381 return r;
382}
383
384int st21nfca_tm_event_send_data(struct nfc_hci_dev *hdev, struct sk_buff *skb,
385 u8 gate)
386{
387 u8 cmd0, cmd1;
388 int r;
389
390 cmd0 = skb->data[1];
391 switch (cmd0) {
392 case ST21NFCA_NFCIP1_REQ:
393 cmd1 = skb->data[2];
394 switch (cmd1) {
395 case ST21NFCA_NFCIP1_ATR_REQ:
396 r = st21nfca_tm_recv_atr_req(hdev, skb);
397 break;
398 case ST21NFCA_NFCIP1_PSL_REQ:
399 r = st21nfca_tm_recv_psl_req(hdev, skb);
400 break;
401 case ST21NFCA_NFCIP1_DEP_REQ:
402 r = st21nfca_tm_recv_dep_req(hdev, skb);
403 break;
404 default:
405 return 1;
406 }
407 default:
408 return 1;
409 }
410 return r;
411}
412EXPORT_SYMBOL(st21nfca_tm_event_send_data);
413
414static void st21nfca_im_send_psl_req(struct nfc_hci_dev *hdev, u8 did, u8 bsi,
415 u8 bri, u8 lri)
416{
417 struct sk_buff *skb;
418 struct st21nfca_psl_req *psl_req;
419 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
420
421 skb =
422 alloc_skb(sizeof(struct st21nfca_psl_req) + 1, GFP_KERNEL);
423 if (!skb)
424 return;
425 skb_reserve(skb, 1);
426
427 skb_put(skb, sizeof(struct st21nfca_psl_req));
428 psl_req = (struct st21nfca_psl_req *) skb->data;
429
430 psl_req->length = sizeof(struct st21nfca_psl_req);
431 psl_req->cmd0 = ST21NFCA_NFCIP1_REQ;
432 psl_req->cmd1 = ST21NFCA_NFCIP1_PSL_REQ;
433 psl_req->did = did;
434 psl_req->brs = (0x30 & bsi << 4) | (bri & 0x03);
435 psl_req->fsl = lri;
436
437 *skb_push(skb, 1) = info->dep_info.to | 0x10;
438
439 st21nfca_im_send_pdu(info, skb);
440
441 kfree_skb(skb);
442}
443
444#define ST21NFCA_CB_TYPE_READER_F 1
445static void st21nfca_im_recv_atr_res_cb(void *context, struct sk_buff *skb,
446 int err)
447{
448 struct st21nfca_hci_info *info = context;
449 struct st21nfca_atr_res *atr_res;
450 int r;
451
452 if (err != 0)
453 return;
454
455 if (IS_ERR(skb))
456 return;
457
458 switch (info->async_cb_type) {
459 case ST21NFCA_CB_TYPE_READER_F:
460 skb_trim(skb, skb->len - 1);
461 atr_res = (struct st21nfca_atr_res *)skb->data;
462 r = nfc_set_remote_general_bytes(info->hdev->ndev,
463 atr_res->gbi,
464 skb->len - sizeof(struct st21nfca_atr_res));
465 if (r < 0)
466 return;
467
468 if (atr_res->to >= 0x0e)
469 info->dep_info.to = 0x0e;
470 else
471 info->dep_info.to = atr_res->to + 1;
472
473 info->dep_info.to |= 0x10;
474
475 r = nfc_dep_link_is_up(info->hdev->ndev, info->dep_info.idx,
476 NFC_COMM_PASSIVE, NFC_RF_INITIATOR);
477 if (r < 0)
478 return;
479
480 info->dep_info.curr_nfc_dep_pni = 0;
481 if (ST21NFCA_PP2LRI(atr_res->ppi) != info->dep_info.lri)
482 st21nfca_im_send_psl_req(info->hdev, atr_res->did,
483 atr_res->bsi, atr_res->bri,
484 ST21NFCA_PP2LRI(atr_res->ppi));
485 break;
486 default:
487 if (err == 0)
488 kfree_skb(skb);
489 break;
490 }
491}
492
493int st21nfca_im_send_atr_req(struct nfc_hci_dev *hdev, u8 *gb, size_t gb_len)
494{
495 struct sk_buff *skb;
496 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
497 struct st21nfca_atr_req *atr_req;
498 struct nfc_target *target;
499 uint size;
500
501 info->dep_info.to = ST21NFCA_DEFAULT_TIMEOUT;
502 size = ST21NFCA_ATR_REQ_MIN_SIZE + gb_len;
503 if (size > ST21NFCA_ATR_REQ_MAX_SIZE) {
504 PROTOCOL_ERR("14.6.1.1");
505 return -EINVAL;
506 }
507
508 skb =
509 alloc_skb(sizeof(struct st21nfca_atr_req) + gb_len + 1, GFP_KERNEL);
510 if (!skb)
511 return -ENOMEM;
512
513 skb_reserve(skb, 1);
514
515 skb_put(skb, sizeof(struct st21nfca_atr_req));
516
517 atr_req = (struct st21nfca_atr_req *)skb->data;
518 memset(atr_req, 0, sizeof(struct st21nfca_atr_req));
519
520 atr_req->cmd0 = ST21NFCA_NFCIP1_REQ;
521 atr_req->cmd1 = ST21NFCA_NFCIP1_ATR_REQ;
522 memset(atr_req->nfcid3, 0, NFC_NFCID3_MAXSIZE);
523 target = hdev->ndev->targets;
524
525 if (target->sensf_res)
526 memcpy(atr_req->nfcid3, target->sensf_res,
527 target->sensf_res_len);
528 else
529 get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE);
530
531 atr_req->did = 0x0;
532
533 atr_req->bsi = 0x00;
534 atr_req->bri = 0x00;
535 atr_req->ppi = ST21NFCA_LR_BITS_PAYLOAD_SIZE_254B;
536 if (gb_len) {
537 atr_req->ppi |= ST21NFCA_GB_BIT;
538 memcpy(skb_put(skb, gb_len), gb, gb_len);
539 }
540 atr_req->length = sizeof(struct st21nfca_atr_req) + hdev->gb_len;
541
542 *skb_push(skb, 1) = info->dep_info.to | 0x10;
543
544 info->async_cb_type = ST21NFCA_CB_TYPE_READER_F;
545 info->async_cb_context = info;
546 info->async_cb = st21nfca_im_recv_atr_res_cb;
547 info->dep_info.bri = atr_req->bri;
548 info->dep_info.bsi = atr_req->bsi;
549 info->dep_info.lri = ST21NFCA_PP2LRI(atr_req->ppi);
550
551 return nfc_hci_send_cmd_async(hdev, ST21NFCA_RF_READER_F_GATE,
552 ST21NFCA_WR_XCHG_DATA, skb->data,
553 skb->len, info->async_cb, info);
554}
555EXPORT_SYMBOL(st21nfca_im_send_atr_req);
556
557static void st21nfca_im_recv_dep_res_cb(void *context, struct sk_buff *skb,
558 int err)
559{
560 struct st21nfca_hci_info *info = context;
561 struct st21nfca_dep_req_res *dep_res;
562
563 int size;
564
565 if (err != 0)
566 return;
567
568 if (IS_ERR(skb))
569 return;
570
571 switch (info->async_cb_type) {
572 case ST21NFCA_CB_TYPE_READER_F:
573 dep_res = (struct st21nfca_dep_req_res *)skb->data;
574
575 size = 3;
576 if (skb->len < size)
577 goto exit;
578
579 if (ST21NFCA_NFC_DEP_DID_BIT_SET(dep_res->pfb))
580 size++;
581 if (ST21NFCA_NFC_DEP_NAD_BIT_SET(dep_res->pfb))
582 size++;
583
584 if (skb->len < size)
585 goto exit;
586
587 skb_trim(skb, skb->len - 1);
588
589
590 switch (ST21NFCA_NFC_DEP_PFB_TYPE(dep_res->pfb)) {
591 case ST21NFCA_NFC_DEP_PFB_ACK_NACK_PDU:
592 pr_err("Received a ACK/NACK PDU\n");
593 case ST21NFCA_NFC_DEP_PFB_I_PDU:
594 info->dep_info.curr_nfc_dep_pni =
595 ST21NFCA_NFC_DEP_PFB_PNI(dep_res->pfb + 1);
596 size++;
597 skb_pull(skb, size);
598 nfc_tm_data_received(info->hdev->ndev, skb);
599 break;
600 case ST21NFCA_NFC_DEP_PFB_SUPERVISOR_PDU:
601 pr_err("Received a SUPERVISOR PDU\n");
602 skb_pull(skb, size);
603 *skb_push(skb, 1) = ST21NFCA_NFCIP1_DEP_REQ;
604 *skb_push(skb, 1) = ST21NFCA_NFCIP1_REQ;
605 *skb_push(skb, 1) = skb->len;
606 *skb_push(skb, 1) = info->dep_info.to | 0x10;
607
608 st21nfca_im_send_pdu(info, skb);
609 break;
610 }
611
612 return;
613 default:
614 break;
615 }
616
617exit:
618 if (err == 0)
619 kfree_skb(skb);
620}
621
622int st21nfca_im_send_dep_req(struct nfc_hci_dev *hdev, struct sk_buff *skb)
623{
624 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
625
626 info->async_cb_type = ST21NFCA_CB_TYPE_READER_F;
627 info->async_cb_context = info;
628 info->async_cb = st21nfca_im_recv_dep_res_cb;
629
630 *skb_push(skb, 1) = info->dep_info.curr_nfc_dep_pni;
631 *skb_push(skb, 1) = ST21NFCA_NFCIP1_DEP_REQ;
632 *skb_push(skb, 1) = ST21NFCA_NFCIP1_REQ;
633 *skb_push(skb, 1) = skb->len;
634
635 *skb_push(skb, 1) = info->dep_info.to | 0x10;
636
637 return nfc_hci_send_cmd_async(hdev, ST21NFCA_RF_READER_F_GATE,
638 ST21NFCA_WR_XCHG_DATA,
639 skb->data, skb->len,
640 info->async_cb, info);
641}
642EXPORT_SYMBOL(st21nfca_im_send_dep_req);
643
644void st21nfca_dep_init(struct nfc_hci_dev *hdev)
645{
646 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
647
648 INIT_WORK(&info->dep_info.tx_work, st21nfca_tx_work);
649 info->dep_info.curr_nfc_dep_pni = 0;
650 info->dep_info.idx = 0;
651 info->dep_info.to = ST21NFCA_DEFAULT_TIMEOUT;
652}
653EXPORT_SYMBOL(st21nfca_dep_init);
654
655void st21nfca_dep_deinit(struct nfc_hci_dev *hdev)
656{
657 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
658
659 cancel_work_sync(&info->dep_info.tx_work);
660}
661EXPORT_SYMBOL(st21nfca_dep_deinit);
662
