Merge tag 'firewire-updates' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee1394/linux1394

+30 -9

drivers/firewire/core-device.c

··· 165 165 return (match & id_table->match_flags) == id_table->match_flags; 166 166 } 167 167 168 - static bool is_fw_unit(struct device *dev); 169 - 170 - static int fw_unit_match(struct device *dev, struct device_driver *drv) 168 + static const struct ieee1394_device_id *unit_match(struct device *dev, 169 + struct device_driver *drv) 171 170 { 172 171 const struct ieee1394_device_id *id_table = 173 172 container_of(drv, struct fw_driver, driver)->id_table; 174 173 int id[] = {0, 0, 0, 0}; 175 174 176 - /* We only allow binding to fw_units. */ 177 - if (!is_fw_unit(dev)) 178 - return 0; 179 - 180 175 get_modalias_ids(fw_unit(dev), id); 181 176 182 177 for (; id_table->match_flags != 0; id_table++) 183 178 if (match_ids(id_table, id)) 184 - return 1; 179 + return id_table; 185 180 186 - return 0; 181 + return NULL; 182 + } 183 + 184 + static bool is_fw_unit(struct device *dev); 185 + 186 + static int fw_unit_match(struct device *dev, struct device_driver *drv) 187 + { 188 + /* We only allow binding to fw_units. */ 189 + return is_fw_unit(dev) && unit_match(dev, drv) != NULL; 190 + } 191 + 192 + static int fw_unit_probe(struct device *dev) 193 + { 194 + struct fw_driver *driver = 195 + container_of(dev->driver, struct fw_driver, driver); 196 + 197 + return driver->probe(fw_unit(dev), unit_match(dev, dev->driver)); 198 + } 199 + 200 + static int fw_unit_remove(struct device *dev) 201 + { 202 + struct fw_driver *driver = 203 + container_of(dev->driver, struct fw_driver, driver); 204 + 205 + return driver->remove(fw_unit(dev)), 0; 187 206 } 188 207 189 208 static int get_modalias(struct fw_unit *unit, char *buffer, size_t buffer_size) ··· 232 213 struct bus_type fw_bus_type = { 233 214 .name = "firewire", 234 215 .match = fw_unit_match, 216 + .probe = fw_unit_probe, 217 + .remove = fw_unit_remove, 235 218 }; 236 219 EXPORT_SYMBOL(fw_bus_type); 237 220

+24 -26

drivers/firewire/net.c

··· 1440 1440 return 0; 1441 1441 } 1442 1442 1443 - static int fwnet_probe(struct device *_dev) 1443 + static int fwnet_probe(struct fw_unit *unit, 1444 + const struct ieee1394_device_id *id) 1444 1445 { 1445 - struct fw_unit *unit = fw_unit(_dev); 1446 1446 struct fw_device *device = fw_parent_device(unit); 1447 1447 struct fw_card *card = device->card; 1448 1448 struct net_device *net; ··· 1526 1526 return ret; 1527 1527 } 1528 1528 1529 + /* 1530 + * FIXME abort partially sent fragmented datagrams, 1531 + * discard partially received fragmented datagrams 1532 + */ 1533 + static void fwnet_update(struct fw_unit *unit) 1534 + { 1535 + struct fw_device *device = fw_parent_device(unit); 1536 + struct fwnet_peer *peer = dev_get_drvdata(&unit->device); 1537 + int generation; 1538 + 1539 + generation = device->generation; 1540 + 1541 + spin_lock_irq(&peer->dev->lock); 1542 + peer->node_id = device->node_id; 1543 + peer->generation = generation; 1544 + spin_unlock_irq(&peer->dev->lock); 1545 + } 1546 + 1529 1547 static void fwnet_remove_peer(struct fwnet_peer *peer, struct fwnet_device *dev) 1530 1548 { 1531 1549 struct fwnet_partial_datagram *pd, *pd_next; ··· 1560 1542 kfree(peer); 1561 1543 } 1562 1544 1563 - static int fwnet_remove(struct device *_dev) 1545 + static void fwnet_remove(struct fw_unit *unit) 1564 1546 { 1565 - struct fwnet_peer *peer = dev_get_drvdata(_dev); 1547 + struct fwnet_peer *peer = dev_get_drvdata(&unit->device); 1566 1548 struct fwnet_device *dev = peer->dev; 1567 1549 struct net_device *net; 1568 1550 int i; ··· 1587 1569 } 1588 1570 1589 1571 mutex_unlock(&fwnet_device_mutex); 1590 - 1591 - return 0; 1592 - } 1593 - 1594 - /* 1595 - * FIXME abort partially sent fragmented datagrams, 1596 - * discard partially received fragmented datagrams 1597 - */ 1598 - static void fwnet_update(struct fw_unit *unit) 1599 - { 1600 - struct fw_device *device = fw_parent_device(unit); 1601 - struct fwnet_peer *peer = dev_get_drvdata(&unit->device); 1602 - int generation; 1603 - 1604 - generation = device->generation; 1605 - 1606 - spin_lock_irq(&peer->dev->lock); 1607 - peer->node_id = device->node_id; 1608 - peer->generation = generation; 1609 - spin_unlock_irq(&peer->dev->lock); 1610 1572 } 1611 1573 1612 1574 static const struct ieee1394_device_id fwnet_id_table[] = { ··· 1612 1614 .owner = THIS_MODULE, 1613 1615 .name = KBUILD_MODNAME, 1614 1616 .bus = &fw_bus_type, 1615 - .probe = fwnet_probe, 1616 - .remove = fwnet_remove, 1617 1617 }, 1618 + .probe = fwnet_probe, 1618 1619 .update = fwnet_update, 1620 + .remove = fwnet_remove, 1619 1621 .id_table = fwnet_id_table, 1620 1622 }; 1621 1623

+7 -10

drivers/firewire/sbp2.c

··· 1128 1128 } 1129 1129 1130 1130 static struct scsi_host_template scsi_driver_template; 1131 - static int sbp2_remove(struct device *dev); 1131 + static void sbp2_remove(struct fw_unit *unit); 1132 1132 1133 - static int sbp2_probe(struct device *dev) 1133 + static int sbp2_probe(struct fw_unit *unit, const struct ieee1394_device_id *id) 1134 1134 { 1135 - struct fw_unit *unit = fw_unit(dev); 1136 1135 struct fw_device *device = fw_parent_device(unit); 1137 1136 struct sbp2_target *tgt; 1138 1137 struct sbp2_logical_unit *lu; ··· 1195 1196 return 0; 1196 1197 1197 1198 fail_remove: 1198 - sbp2_remove(dev); 1199 + sbp2_remove(unit); 1199 1200 return -ENOMEM; 1200 1201 1201 1202 fail_shost_put: ··· 1221 1222 } 1222 1223 } 1223 1224 1224 - static int sbp2_remove(struct device *dev) 1225 + static void sbp2_remove(struct fw_unit *unit) 1225 1226 { 1226 - struct fw_unit *unit = fw_unit(dev); 1227 1227 struct fw_device *device = fw_parent_device(unit); 1228 1228 struct sbp2_target *tgt = dev_get_drvdata(&unit->device); 1229 1229 struct sbp2_logical_unit *lu, *next; ··· 1259 1261 kfree(lu); 1260 1262 } 1261 1263 scsi_remove_host(shost); 1262 - dev_notice(dev, "released target %d:0:0\n", shost->host_no); 1264 + dev_notice(&unit->device, "released target %d:0:0\n", shost->host_no); 1263 1265 1264 1266 scsi_host_put(shost); 1265 - return 0; 1266 1267 } 1267 1268 1268 1269 #define SBP2_UNIT_SPEC_ID_ENTRY 0x0000609e ··· 1282 1285 .owner = THIS_MODULE, 1283 1286 .name = KBUILD_MODNAME, 1284 1287 .bus = &fw_bus_type, 1285 - .probe = sbp2_probe, 1286 - .remove = sbp2_remove, 1287 1288 }, 1289 + .probe = sbp2_probe, 1288 1290 .update = sbp2_update, 1291 + .remove = sbp2_remove, 1289 1292 .id_table = sbp2_id_table, 1290 1293 }; 1291 1294

+9 -10

drivers/media/firewire/firedtv-fw.c

··· 248 248 /* Adjust the template string if models with longer names appear. */ 249 249 #define MAX_MODEL_NAME_LEN sizeof("FireDTV ????") 250 250 251 - static int node_probe(struct device *dev) 251 + static int node_probe(struct fw_unit *unit, const struct ieee1394_device_id *id) 252 252 { 253 253 struct firedtv *fdtv; 254 254 char name[MAX_MODEL_NAME_LEN]; ··· 258 258 if (!fdtv) 259 259 return -ENOMEM; 260 260 261 - dev_set_drvdata(dev, fdtv); 262 - fdtv->device = dev; 261 + dev_set_drvdata(&unit->device, fdtv); 262 + fdtv->device = &unit->device; 263 263 fdtv->isochannel = -1; 264 264 fdtv->voltage = 0xff; 265 265 fdtv->tone = 0xff; ··· 269 269 mutex_init(&fdtv->demux_mutex); 270 270 INIT_WORK(&fdtv->remote_ctrl_work, avc_remote_ctrl_work); 271 271 272 - name_len = fw_csr_string(fw_unit(dev)->directory, CSR_MODEL, 272 + name_len = fw_csr_string(unit->directory, CSR_MODEL, 273 273 name, sizeof(name)); 274 274 for (i = ARRAY_SIZE(model_names); --i; ) 275 275 if (strlen(model_names[i]) <= name_len && ··· 277 277 break; 278 278 fdtv->type = i; 279 279 280 - err = fdtv_register_rc(fdtv, dev); 280 + err = fdtv_register_rc(fdtv, &unit->device); 281 281 if (err) 282 282 goto fail_free; 283 283 ··· 307 307 return err; 308 308 } 309 309 310 - static int node_remove(struct device *dev) 310 + static void node_remove(struct fw_unit *unit) 311 311 { 312 - struct firedtv *fdtv = dev_get_drvdata(dev); 312 + struct firedtv *fdtv = dev_get_drvdata(&unit->device); 313 313 314 314 fdtv_dvb_unregister(fdtv); 315 315 ··· 320 320 fdtv_unregister_rc(fdtv); 321 321 322 322 kfree(fdtv); 323 - return 0; 324 323 } 325 324 326 325 static void node_update(struct fw_unit *unit) ··· 390 391 .owner = THIS_MODULE, 391 392 .name = "firedtv", 392 393 .bus = &fw_bus_type, 393 - .probe = node_probe, 394 - .remove = node_remove, 395 394 }, 395 + .probe = node_probe, 396 396 .update = node_update, 397 + .remove = node_remove, 397 398 .id_table = fdtv_id_table, 398 399 }; 399 400

+6 -8

drivers/staging/fwserial/fwserial.c

··· 2446 2446 * last peer for a given fw_card triggering the destruction of the same 2447 2447 * fw_serial for the same fw_card. 2448 2448 */ 2449 - static int fwserial_probe(struct device *dev) 2449 + static int fwserial_probe(struct fw_unit *unit, 2450 + const struct ieee1394_device_id *id) 2450 2451 { 2451 - struct fw_unit *unit = fw_unit(dev); 2452 2452 struct fw_serial *serial; 2453 2453 int err; 2454 2454 ··· 2470 2470 * specific fw_card). If this is the last peer being removed, then trigger 2471 2471 * the destruction of the underlying TTYs. 2472 2472 */ 2473 - static int fwserial_remove(struct device *dev) 2473 + static void fwserial_remove(struct fw_unit *unit) 2474 2474 { 2475 - struct fwtty_peer *peer = dev_get_drvdata(dev); 2475 + struct fwtty_peer *peer = dev_get_drvdata(&unit->device); 2476 2476 struct fw_serial *serial = peer->serial; 2477 2477 int i; 2478 2478 ··· 2492 2492 kref_put(&serial->kref, fwserial_destroy); 2493 2493 } 2494 2494 mutex_unlock(&fwserial_list_mutex); 2495 - 2496 - return 0; 2497 2495 } 2498 2496 2499 2497 /** ··· 2536 2538 .owner = THIS_MODULE, 2537 2539 .name = KBUILD_MODNAME, 2538 2540 .bus = &fw_bus_type, 2539 - .probe = fwserial_probe, 2540 - .remove = fwserial_remove, 2541 2541 }, 2542 + .probe = fwserial_probe, 2542 2543 .update = fwserial_update, 2544 + .remove = fwserial_remove, 2543 2545 .id_table = fwserial_id_table, 2544 2546 }; 2545 2547

+2

include/linux/firewire.h

··· 251 251 252 252 struct fw_driver { 253 253 struct device_driver driver; 254 + int (*probe)(struct fw_unit *unit, const struct ieee1394_device_id *id); 254 255 /* Called when the parent device sits through a bus reset. */ 255 256 void (*update)(struct fw_unit *unit); 257 + void (*remove)(struct fw_unit *unit); 256 258 const struct ieee1394_device_id *id_table; 257 259 }; 258 260

+21 -23

sound/firewire/isight.c

··· 626 626 return 0; 627 627 } 628 628 629 - static int isight_probe(struct device *unit_dev) 629 + static int isight_probe(struct fw_unit *unit, 630 + const struct ieee1394_device_id *id) 630 631 { 631 - struct fw_unit *unit = fw_unit(unit_dev); 632 632 struct fw_device *fw_dev = fw_parent_device(unit); 633 633 struct snd_card *card; 634 634 struct isight *isight; ··· 637 637 err = snd_card_create(-1, NULL, THIS_MODULE, sizeof(*isight), &card); 638 638 if (err < 0) 639 639 return err; 640 - snd_card_set_dev(card, unit_dev); 640 + snd_card_set_dev(card, &unit->device); 641 641 642 642 isight = card->private_data; 643 643 isight->card = card; ··· 674 674 if (err < 0) 675 675 goto error; 676 676 677 - dev_set_drvdata(unit_dev, isight); 677 + dev_set_drvdata(&unit->device, isight); 678 678 679 679 return 0; 680 680 ··· 684 684 error: 685 685 snd_card_free(card); 686 686 return err; 687 - } 688 - 689 - static int isight_remove(struct device *dev) 690 - { 691 - struct isight *isight = dev_get_drvdata(dev); 692 - 693 - isight_pcm_abort(isight); 694 - 695 - snd_card_disconnect(isight->card); 696 - 697 - mutex_lock(&isight->mutex); 698 - isight_stop_streaming(isight); 699 - mutex_unlock(&isight->mutex); 700 - 701 - snd_card_free_when_closed(isight->card); 702 - 703 - return 0; 704 687 } 705 688 706 689 static void isight_bus_reset(struct fw_unit *unit) ··· 697 714 isight_stop_streaming(isight); 698 715 mutex_unlock(&isight->mutex); 699 716 } 717 + } 718 + 719 + static void isight_remove(struct fw_unit *unit) 720 + { 721 + struct isight *isight = dev_get_drvdata(&unit->device); 722 + 723 + isight_pcm_abort(isight); 724 + 725 + snd_card_disconnect(isight->card); 726 + 727 + mutex_lock(&isight->mutex); 728 + isight_stop_streaming(isight); 729 + mutex_unlock(&isight->mutex); 730 + 731 + snd_card_free_when_closed(isight->card); 700 732 } 701 733 702 734 static const struct ieee1394_device_id isight_id_table[] = { ··· 730 732 .owner = THIS_MODULE, 731 733 .name = KBUILD_MODNAME, 732 734 .bus = &fw_bus_type, 733 - .probe = isight_probe, 734 - .remove = isight_remove, 735 735 }, 736 + .probe = isight_probe, 736 737 .update = isight_bus_reset, 738 + .remove = isight_remove, 737 739 .id_table = isight_id_table, 738 740 }; 739 741

+21 -24

sound/firewire/scs1x.c

··· 384 384 kfree(scs->buffer); 385 385 } 386 386 387 - static int scs_probe(struct device *unit_dev) 387 + static int scs_probe(struct fw_unit *unit, const struct ieee1394_device_id *id) 388 388 { 389 - struct fw_unit *unit = fw_unit(unit_dev); 390 389 struct fw_device *fw_dev = fw_parent_device(unit); 391 390 struct snd_card *card; 392 391 struct scs *scs; ··· 394 395 err = snd_card_create(-16, NULL, THIS_MODULE, sizeof(*scs), &card); 395 396 if (err < 0) 396 397 return err; 397 - snd_card_set_dev(card, unit_dev); 398 + snd_card_set_dev(card, &unit->device); 398 399 399 400 scs = card->private_data; 400 401 scs->card = card; ··· 441 442 if (err < 0) 442 443 goto err_card; 443 444 444 - dev_set_drvdata(unit_dev, scs); 445 + dev_set_drvdata(&unit->device, scs); 445 446 446 447 return 0; 447 448 ··· 450 451 err_card: 451 452 snd_card_free(card); 452 453 return err; 453 - } 454 - 455 - static int scs_remove(struct device *dev) 456 - { 457 - struct scs *scs = dev_get_drvdata(dev); 458 - 459 - snd_card_disconnect(scs->card); 460 - 461 - ACCESS_ONCE(scs->output) = NULL; 462 - ACCESS_ONCE(scs->input) = NULL; 463 - 464 - wait_event(scs->idle_wait, scs->output_idle); 465 - 466 - tasklet_kill(&scs->tasklet); 467 - 468 - snd_card_free_when_closed(scs->card); 469 - 470 - return 0; 471 454 } 472 455 473 456 static void scs_update(struct fw_unit *unit) ··· 461 480 scs->hss_handler.offset); 462 481 snd_fw_transaction(scs->unit, TCODE_WRITE_BLOCK_REQUEST, 463 482 HSS1394_ADDRESS, &data, 8); 483 + } 484 + 485 + static void scs_remove(struct fw_unit *unit) 486 + { 487 + struct scs *scs = dev_get_drvdata(&unit->device); 488 + 489 + snd_card_disconnect(scs->card); 490 + 491 + ACCESS_ONCE(scs->output) = NULL; 492 + ACCESS_ONCE(scs->input) = NULL; 493 + 494 + wait_event(scs->idle_wait, scs->output_idle); 495 + 496 + tasklet_kill(&scs->tasklet); 497 + 498 + snd_card_free_when_closed(scs->card); 464 499 } 465 500 466 501 static const struct ieee1394_device_id scs_id_table[] = { ··· 505 508 .owner = THIS_MODULE, 506 509 .name = KBUILD_MODNAME, 507 510 .bus = &fw_bus_type, 508 - .probe = scs_probe, 509 - .remove = scs_remove, 510 511 }, 512 + .probe = scs_probe, 511 513 .update = scs_update, 514 + .remove = scs_remove, 512 515 .id_table = scs_id_table, 513 516 }; 514 517

+43 -63

sound/firewire/speakers.c

··· 663 663 mutex_destroy(&fwspk->mutex); 664 664 } 665 665 666 - static const struct device_info *fwspk_detect(struct fw_device *dev) 666 + static int fwspk_probe(struct fw_unit *unit, 667 + const struct ieee1394_device_id *id) 667 668 { 668 - static const struct device_info griffin_firewave = { 669 - .driver_name = "FireWave", 670 - .short_name = "FireWave", 671 - .long_name = "Griffin FireWave Surround", 672 - .pcm_constraints = firewave_constraints, 673 - .mixer_channels = 6, 674 - .mute_fb_id = 0x01, 675 - .volume_fb_id = 0x02, 676 - }; 677 - static const struct device_info lacie_speakers = { 678 - .driver_name = "FWSpeakers", 679 - .short_name = "FireWire Speakers", 680 - .long_name = "LaCie FireWire Speakers", 681 - .pcm_constraints = lacie_speakers_constraints, 682 - .mixer_channels = 1, 683 - .mute_fb_id = 0x01, 684 - .volume_fb_id = 0x01, 685 - }; 686 - struct fw_csr_iterator i; 687 - int key, value; 688 - 689 - fw_csr_iterator_init(&i, dev->config_rom); 690 - while (fw_csr_iterator_next(&i, &key, &value)) 691 - if (key == CSR_VENDOR) 692 - switch (value) { 693 - case VENDOR_GRIFFIN: 694 - return &griffin_firewave; 695 - case VENDOR_LACIE: 696 - return &lacie_speakers; 697 - } 698 - 699 - return NULL; 700 - } 701 - 702 - static int fwspk_probe(struct device *unit_dev) 703 - { 704 - struct fw_unit *unit = fw_unit(unit_dev); 705 669 struct fw_device *fw_dev = fw_parent_device(unit); 706 670 struct snd_card *card; 707 671 struct fwspk *fwspk; ··· 675 711 err = snd_card_create(-1, NULL, THIS_MODULE, sizeof(*fwspk), &card); 676 712 if (err < 0) 677 713 return err; 678 - snd_card_set_dev(card, unit_dev); 714 + snd_card_set_dev(card, &unit->device); 679 715 680 716 fwspk = card->private_data; 681 717 fwspk->card = card; 682 718 mutex_init(&fwspk->mutex); 683 719 fwspk->unit = fw_unit_get(unit); 684 - fwspk->device_info = fwspk_detect(fw_dev); 685 - if (!fwspk->device_info) { 686 - err = -ENODEV; 687 - goto err_unit; 688 - } 720 + fwspk->device_info = (const struct device_info *)id->driver_data; 689 721 690 722 err = cmp_connection_init(&fwspk->connection, unit, 0); 691 723 if (err < 0) ··· 716 756 if (err < 0) 717 757 goto error; 718 758 719 - dev_set_drvdata(unit_dev, fwspk); 759 + dev_set_drvdata(&unit->device, fwspk); 720 760 721 761 return 0; 722 762 ··· 728 768 error: 729 769 snd_card_free(card); 730 770 return err; 731 - } 732 - 733 - static int fwspk_remove(struct device *dev) 734 - { 735 - struct fwspk *fwspk = dev_get_drvdata(dev); 736 - 737 - amdtp_out_stream_pcm_abort(&fwspk->stream); 738 - snd_card_disconnect(fwspk->card); 739 - 740 - mutex_lock(&fwspk->mutex); 741 - fwspk_stop_stream(fwspk); 742 - mutex_unlock(&fwspk->mutex); 743 - 744 - snd_card_free_when_closed(fwspk->card); 745 - 746 - return 0; 747 771 } 748 772 749 773 static void fwspk_bus_reset(struct fw_unit *unit) ··· 747 803 amdtp_out_stream_update(&fwspk->stream); 748 804 } 749 805 806 + static void fwspk_remove(struct fw_unit *unit) 807 + { 808 + struct fwspk *fwspk = dev_get_drvdata(&unit->device); 809 + 810 + amdtp_out_stream_pcm_abort(&fwspk->stream); 811 + snd_card_disconnect(fwspk->card); 812 + 813 + mutex_lock(&fwspk->mutex); 814 + fwspk_stop_stream(fwspk); 815 + mutex_unlock(&fwspk->mutex); 816 + 817 + snd_card_free_when_closed(fwspk->card); 818 + } 819 + 820 + static const struct device_info griffin_firewave = { 821 + .driver_name = "FireWave", 822 + .short_name = "FireWave", 823 + .long_name = "Griffin FireWave Surround", 824 + .pcm_constraints = firewave_constraints, 825 + .mixer_channels = 6, 826 + .mute_fb_id = 0x01, 827 + .volume_fb_id = 0x02, 828 + }; 829 + 830 + static const struct device_info lacie_speakers = { 831 + .driver_name = "FWSpeakers", 832 + .short_name = "FireWire Speakers", 833 + .long_name = "LaCie FireWire Speakers", 834 + .pcm_constraints = lacie_speakers_constraints, 835 + .mixer_channels = 1, 836 + .mute_fb_id = 0x01, 837 + .volume_fb_id = 0x01, 838 + }; 839 + 750 840 static const struct ieee1394_device_id fwspk_id_table[] = { 751 841 { 752 842 .match_flags = IEEE1394_MATCH_VENDOR_ID | ··· 791 813 .model_id = 0x00f970, 792 814 .specifier_id = SPECIFIER_1394TA, 793 815 .version = VERSION_AVC, 816 + .driver_data = (kernel_ulong_t)&griffin_firewave, 794 817 }, 795 818 { 796 819 .match_flags = IEEE1394_MATCH_VENDOR_ID | ··· 802 823 .model_id = 0x00f970, 803 824 .specifier_id = SPECIFIER_1394TA, 804 825 .version = VERSION_AVC, 826 + .driver_data = (kernel_ulong_t)&lacie_speakers, 805 827 }, 806 828 { } 807 829 }; ··· 813 833 .owner = THIS_MODULE, 814 834 .name = KBUILD_MODNAME, 815 835 .bus = &fw_bus_type, 816 - .probe = fwspk_probe, 817 - .remove = fwspk_remove, 818 836 }, 837 + .probe = fwspk_probe, 819 838 .update = fwspk_bus_reset, 839 + .remove = fwspk_remove, 820 840 .id_table = fwspk_id_table, 821 841 }; 822 842

Configure Feed

Configure Feed