2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Written by: David Jeffery
5 * Copyright (c) 2002 Adaptec Inc.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
33 #include <dev/ips/ipsreg.h>
34 #include <dev/ips/ips.h>
38 static d_open_t ips_open;
39 static d_close_t ips_close;
40 static d_ioctl_t ips_ioctl;
42 MALLOC_DEFINE(M_IPSBUF, "ipsbuf","IPS driver buffer");
44 static struct cdevsw ips_cdevsw = {
45 .d_version = D_VERSION,
52 static const char* ips_adapter_name[] = {
54 "ServeRAID (copperhead)",
55 "ServeRAID II (copperhead refresh)",
56 "ServeRAID onboard (copperhead)",
57 "ServeRAID onboard (copperhead)",
58 "ServeRAID 3H (clarinet)",
59 "ServeRAID 3L (clarinet lite)",
60 "ServeRAID 4H (trombone)",
61 "ServeRAID 4M (morpheus)",
62 "ServeRAID 4L (morpheus lite)",
63 "ServeRAID 4Mx (neo)",
64 "ServeRAID 4Lx (neo lite)",
65 "ServeRAID 5i II (sarasota)",
66 "ServeRAID 5i (sarasota)",
67 "ServeRAID 6M (marco)",
68 "ServeRAID 6i (sebring)",
75 static int ips_open(struct cdev *dev, int flags, int fmt, struct thread *td)
77 ips_softc_t *sc = dev->si_drv1;
78 mtx_lock(&sc->queue_mtx);
79 sc->state |= IPS_DEV_OPEN;
80 mtx_unlock(&sc->queue_mtx);
84 static int ips_close(struct cdev *dev, int flags, int fmt, struct thread *td)
86 ips_softc_t *sc = dev->si_drv1;
88 mtx_lock(&sc->queue_mtx);
89 sc->state &= ~IPS_DEV_OPEN;
90 mtx_unlock(&sc->queue_mtx);
95 static int ips_ioctl(struct cdev *dev, u_long command, caddr_t addr, int32_t flags, struct thread *td)
100 return ips_ioctl_request(sc, command, addr, flags);
103 static void ips_cmd_dmaload(void *cmdptr, bus_dma_segment_t *segments,int segnum, int error)
105 ips_command_t *command = cmdptr;
106 PRINTF(10, "ips: in ips_cmd_dmaload\n");
108 command->command_phys_addr = segments[0].ds_addr;
112 /* is locking needed? what locking guarantees are there on removal? */
113 static int ips_cmdqueue_free(ips_softc_t *sc)
116 ips_command_t *command;
118 if(!sc->used_commands){
119 for(i = 0; i < sc->max_cmds; i++){
121 command = &sc->commandarray[i];
123 if(command->command_phys_addr == 0)
125 bus_dmamap_unload(sc->command_dmatag,
126 command->command_dmamap);
127 bus_dmamem_free(sc->command_dmatag,
128 command->command_buffer,
129 command->command_dmamap);
130 if (command->data_dmamap != NULL)
131 bus_dmamap_destroy(command->data_dmatag,
132 command->data_dmamap);
135 sc->state |= IPS_OFFLINE;
137 sc->staticcmd = NULL;
138 free(sc->commandarray, M_DEVBUF);
142 /* places all ips command structs on the free command queue. No locking as if someone else tries
143 * to access this during init, we have bigger problems */
144 static int ips_cmdqueue_init(ips_softc_t *sc)
147 ips_command_t *command;
149 sc->commandarray = (ips_command_t *)malloc(sizeof(ips_command_t) *
150 sc->max_cmds, M_DEVBUF, M_NOWAIT|M_ZERO);
151 if (sc->commandarray == NULL)
154 SLIST_INIT(&sc->free_cmd_list);
155 for(i = 0; i < sc->max_cmds; i++){
156 command = &sc->commandarray[i];
160 if(bus_dmamem_alloc(sc->command_dmatag,&command->command_buffer,
161 BUS_DMA_NOWAIT, &command->command_dmamap))
163 bus_dmamap_load(sc->command_dmatag, command->command_dmamap,
164 command->command_buffer,IPS_COMMAND_LEN,
165 ips_cmd_dmaload, command, BUS_DMA_NOWAIT);
166 if(!command->command_phys_addr){
167 bus_dmamem_free(sc->command_dmatag,
168 command->command_buffer, command->command_dmamap);
173 command->data_dmatag = sc->sg_dmatag;
174 if (bus_dmamap_create(command->data_dmatag, 0,
175 &command->data_dmamap))
177 SLIST_INSERT_HEAD(&sc->free_cmd_list, command, next);
179 sc->staticcmd = command;
181 sc->state &= ~IPS_OFFLINE;
184 ips_cmdqueue_free(sc);
188 /* returns a free command struct if one is available.
189 * It also blanks out anything that may be a wild pointer/value.
190 * Also, command buffers are not freed. They are
191 * small so they are saved and kept dmamapped and loaded.
193 int ips_get_free_cmd(ips_softc_t *sc, ips_command_t **cmd, unsigned long flags)
195 ips_command_t *command;
197 if(sc->state & IPS_OFFLINE){
200 if ((flags & IPS_STATIC_FLAG) == 0) {
201 command = SLIST_FIRST(&sc->free_cmd_list);
202 if(!command || (sc->state & IPS_TIMEOUT)){
205 SLIST_REMOVE_HEAD(&sc->free_cmd_list, next);
206 (sc->used_commands)++;
208 if (sc->state & IPS_STATIC_BUSY)
210 command = sc->staticcmd;
211 sc->state |= IPS_STATIC_BUSY;
213 clear_ips_command(command);
214 bzero(command->command_buffer, IPS_COMMAND_LEN);
219 /* adds a command back to the free command queue */
220 void ips_insert_free_cmd(ips_softc_t *sc, ips_command_t *command)
223 if (sema_value(&sc->cmd_sema) != 0)
224 panic("ips: command returned non-zero semaphore");
226 if (command != sc->staticcmd) {
227 SLIST_INSERT_HEAD(&sc->free_cmd_list, command, next);
228 (sc->used_commands)--;
230 sc->state &= ~IPS_STATIC_BUSY;
233 static const char* ips_diskdev_statename(u_int8_t state)
235 static char statebuf[20];
243 case IPS_LD_DEGRADED:
256 sprintf(statebuf,"UNKNOWN(0x%02x)", state);
260 static int ips_diskdev_init(ips_softc_t *sc)
263 for(i=0; i < IPS_MAX_NUM_DRIVES; i++){
264 if(sc->drives[i].state == IPS_LD_FREE) continue;
265 device_printf(sc->dev, "Logical Drive %d: RAID%d sectors: %u, state %s\n",
266 i, sc->drives[i].raid_lvl,
267 sc->drives[i].sector_count,
268 ips_diskdev_statename(sc->drives[i].state));
269 if(sc->drives[i].state == IPS_LD_OKAY ||
270 sc->drives[i].state == IPS_LD_DEGRADED){
271 sc->diskdev[i] = device_add_child(sc->dev, NULL, -1);
272 device_set_ivars(sc->diskdev[i],(void *)(uintptr_t) i);
275 if(bus_generic_attach(sc->dev)){
276 device_printf(sc->dev, "Attaching bus failed\n");
281 static int ips_diskdev_free(ips_softc_t *sc)
285 for(i = 0; i < IPS_MAX_NUM_DRIVES; i++){
287 error = device_delete_child(sc->dev, sc->diskdev[i]);
291 bus_generic_detach(sc->dev);
295 /* ips_timeout is periodically called to make sure no commands sent
296 * to the card have become stuck. If it finds a stuck command, it
297 * sets a flag so the driver won't start any more commands and then
298 * is periodically called to see if all outstanding commands have
299 * either finished or timed out. Once timed out, an attempt to
300 * reinitialize the card is made. If that fails, the driver gives
301 * up and declares the card dead. */
302 static void ips_timeout(void *arg)
304 ips_softc_t *sc = arg;
306 ips_command_t *command;
308 mtx_assert(&sc->queue_mtx, MA_OWNED);
309 command = &sc->commandarray[0];
310 for(i = 0; i < sc->max_cmds; i++){
311 if(!command[i].timeout){
314 command[i].timeout--;
315 if(!command[i].timeout){
316 if(!(sc->state & IPS_TIMEOUT)){
317 sc->state |= IPS_TIMEOUT;
318 device_printf(sc->dev, "WARNING: command timeout. Adapter is in toaster mode, resetting to known state\n");
320 ips_set_error(&command[i], ETIMEDOUT);
321 command[i].callback(&command[i]);
322 /* hmm, this should be enough cleanup */
326 if(!state && (sc->state & IPS_TIMEOUT)){
327 if(sc->ips_adapter_reinit(sc, 1)){
328 device_printf(sc->dev, "AIEE! adapter reset failed, giving up and going home! Have a nice day.\n");
329 sc->state |= IPS_OFFLINE;
330 sc->state &= ~IPS_TIMEOUT;
331 /* Grr, I hate this solution. I run waiting commands
332 one at a time and error them out just before they
333 would go to the card. This sucks. */
335 sc->state &= ~IPS_TIMEOUT;
337 if (sc->state != IPS_OFFLINE)
338 callout_reset(&sc->timer, 10 * hz, ips_timeout, sc);
341 /* check card and initialize it */
342 int ips_adapter_init(ips_softc_t *sc)
345 DEVICE_PRINTF(1,sc->dev, "initializing\n");
347 if (bus_dma_tag_create( /* parent */ sc->adapter_dmatag,
350 /* lowaddr */ BUS_SPACE_MAXADDR_32BIT,
351 /* highaddr */ BUS_SPACE_MAXADDR,
353 /* filterarg */ NULL,
354 /* maxsize */ IPS_COMMAND_LEN +
357 /* maxsegsize*/ IPS_COMMAND_LEN +
362 &sc->command_dmatag) != 0) {
363 device_printf(sc->dev, "can't alloc command dma tag\n");
366 if (bus_dma_tag_create( /* parent */ sc->adapter_dmatag,
369 /* lowaddr */ BUS_SPACE_MAXADDR_32BIT,
370 /* highaddr */ BUS_SPACE_MAXADDR,
372 /* filterarg */ NULL,
373 /* maxsize */ IPS_MAX_IOBUF_SIZE,
374 /* numsegs */ IPS_MAX_SG_ELEMENTS,
375 /* maxsegsize*/ IPS_MAX_IOBUF_SIZE,
377 /* lockfunc */ busdma_lock_mutex,
378 /* lockarg */ &sc->queue_mtx,
379 &sc->sg_dmatag) != 0) {
380 device_printf(sc->dev, "can't alloc SG dma tag\n");
383 /* create one command buffer until we know how many commands this card
386 ips_cmdqueue_init(sc);
388 if(sc->ips_adapter_reinit(sc, 0))
391 /* initialize ffdc values */
392 microtime(&sc->ffdc_resettime);
393 sc->ffdc_resetcount = 1;
394 if ((i = ips_ffdc_reset(sc)) != 0) {
395 device_printf(sc->dev, "failed to send ffdc reset to device (%d)\n", i);
398 if ((i = ips_get_adapter_info(sc)) != 0) {
399 device_printf(sc->dev, "failed to get adapter configuration data from device (%d)\n", i);
402 ips_update_nvram(sc); /* no error check as failure doesn't matter */
403 if(sc->adapter_type > 0 && sc->adapter_type <= IPS_ADAPTER_MAX_T){
404 device_printf(sc->dev, "adapter type: %s\n", ips_adapter_name[sc->adapter_type]);
406 if ((i = ips_get_drive_info(sc)) != 0) {
407 device_printf(sc->dev, "failed to get drive configuration data from device (%d)\n", i);
411 ips_cmdqueue_free(sc);
412 if(sc->adapter_info.max_concurrent_cmds)
413 sc->max_cmds = min(128, sc->adapter_info.max_concurrent_cmds);
416 if(ips_cmdqueue_init(sc)){
417 device_printf(sc->dev, "failed to initialize command buffers\n");
420 sc->device_file = make_dev(&ips_cdevsw, device_get_unit(sc->dev), UID_ROOT, GID_OPERATOR,
421 S_IRUSR | S_IWUSR, "ips%d", device_get_unit(sc->dev));
422 sc->device_file->si_drv1 = sc;
423 ips_diskdev_init(sc);
424 callout_reset(&sc->timer, 10 * hz, ips_timeout, sc);
428 ips_adapter_free(sc);
432 /* see if we should reinitialize the card and wait for it to timeout or complete initialization */
433 int ips_morpheus_reinit(ips_softc_t *sc, int force)
438 tmp = ips_read_4(sc, MORPHEUS_REG_OISR);
439 if(!force && (ips_read_4(sc, MORPHEUS_REG_OMR0) >= IPS_POST1_OK) &&
440 (ips_read_4(sc, MORPHEUS_REG_OMR1) != 0xdeadbeef) && !tmp){
441 ips_write_4(sc, MORPHEUS_REG_OIMR, 0);
444 ips_write_4(sc, MORPHEUS_REG_OIMR, 0xff);
445 ips_read_4(sc, MORPHEUS_REG_OIMR);
447 device_printf(sc->dev, "resetting adapter, this may take up to 5 minutes\n");
448 ips_write_4(sc, MORPHEUS_REG_IDR, 0x80000000);
450 ips_read_4(sc, MORPHEUS_REG_OIMR);
452 tmp = ips_read_4(sc, MORPHEUS_REG_OISR);
453 for(i = 0; i < 45 && !(tmp & MORPHEUS_BIT_POST1); i++){
455 DEVICE_PRINTF(2, sc->dev, "post1: %d\n", i);
456 tmp = ips_read_4(sc, MORPHEUS_REG_OISR);
458 if(tmp & MORPHEUS_BIT_POST1)
459 ips_write_4(sc, MORPHEUS_REG_OISR, MORPHEUS_BIT_POST1);
461 if( i == 45 || ips_read_4(sc, MORPHEUS_REG_OMR0) < IPS_POST1_OK){
462 device_printf(sc->dev,"Adapter error during initialization.\n");
465 for(i = 0; i < 240 && !(tmp & MORPHEUS_BIT_POST2); i++){
467 DEVICE_PRINTF(2, sc->dev, "post2: %d\n", i);
468 tmp = ips_read_4(sc, MORPHEUS_REG_OISR);
470 if(tmp & MORPHEUS_BIT_POST2)
471 ips_write_4(sc, MORPHEUS_REG_OISR, MORPHEUS_BIT_POST2);
473 if(i == 240 || !ips_read_4(sc, MORPHEUS_REG_OMR1)){
474 device_printf(sc->dev, "adapter failed config check\n");
477 ips_write_4(sc, MORPHEUS_REG_OIMR, 0);
478 if(force && ips_clear_adapter(sc)){
479 device_printf(sc->dev, "adapter clear failed\n");
485 /* clean up so we can unload the driver. */
486 int ips_adapter_free(ips_softc_t *sc)
489 if(sc->state & IPS_DEV_OPEN)
491 if((error = ips_diskdev_free(sc)))
493 if(ips_cmdqueue_free(sc)){
494 device_printf(sc->dev,
495 "trying to exit when command queue is not empty!\n");
498 DEVICE_PRINTF(1, sc->dev, "free\n");
499 callout_drain(&sc->timer);
502 bus_dma_tag_destroy(sc->sg_dmatag);
503 if(sc->command_dmatag)
504 bus_dma_tag_destroy(sc->command_dmatag);
506 destroy_dev(sc->device_file);
510 static __inline int ips_morpheus_check_intr(ips_softc_t *sc)
513 ips_cmd_status_t status;
514 ips_command_t *command;
518 oisr = ips_read_4(sc, MORPHEUS_REG_OISR);
519 PRINTF(9, "interrupt registers out:%x\n", oisr);
520 if(!(oisr & MORPHEUS_BIT_CMD_IRQ)){
521 DEVICE_PRINTF(2,sc->dev, "got a non-command irq\n");
524 while((status.value = ips_read_4(sc, MORPHEUS_REG_OQPR)) != 0xffffffff){
525 cmdnumber = status.fields.command_id;
526 command = &sc->commandarray[cmdnumber];
527 command->status.value = status.value;
528 command->timeout = 0;
529 command->callback(command);
536 void ips_morpheus_intr(void *void_sc)
538 ips_softc_t *sc = void_sc;
540 mtx_lock(&sc->queue_mtx);
541 ips_morpheus_check_intr(sc);
542 mtx_unlock(&sc->queue_mtx);
545 void ips_morpheus_poll(ips_command_t *command)
550 * Locks are not used here because this is only called during
553 ts = time_second + command->timeout;
554 while ((command->timeout != 0)
555 && (ips_morpheus_check_intr(command->sc) == 0)
556 && (ts > time_second))
560 void ips_issue_morpheus_cmd(ips_command_t *command)
562 /* hmmm, is there a cleaner way to do this? */
563 if(command->sc->state & IPS_OFFLINE){
564 ips_set_error(command, EINVAL);
565 command->callback(command);
568 command->timeout = 10;
569 ips_write_4(command->sc, MORPHEUS_REG_IQPR, command->command_phys_addr);
572 static void ips_copperhead_queue_callback(void *queueptr, bus_dma_segment_t *segments,int segnum, int error)
574 ips_copper_queue_t *queue = queueptr;
578 queue->base_phys_addr = segments[0].ds_addr;
581 static int ips_copperhead_queue_init(ips_softc_t *sc)
584 bus_dma_tag_t dmatag;
586 if (bus_dma_tag_create( /* parent */ sc->adapter_dmatag,
589 /* lowaddr */ BUS_SPACE_MAXADDR_32BIT,
590 /* highaddr */ BUS_SPACE_MAXADDR,
592 /* filterarg */ NULL,
593 /* maxsize */ sizeof(ips_copper_queue_t),
595 /* maxsegsize*/ sizeof(ips_copper_queue_t),
600 device_printf(sc->dev, "can't alloc dma tag for statue queue\n");
604 if(bus_dmamem_alloc(dmatag, (void *)&(sc->copper_queue),
605 BUS_DMA_NOWAIT, &dmamap)){
609 bzero(sc->copper_queue, sizeof(ips_copper_queue_t));
610 sc->copper_queue->dmatag = dmatag;
611 sc->copper_queue->dmamap = dmamap;
612 sc->copper_queue->nextstatus = 1;
613 bus_dmamap_load(dmatag, dmamap,
614 &(sc->copper_queue->status[0]), IPS_MAX_CMD_NUM * 4,
615 ips_copperhead_queue_callback, sc->copper_queue,
617 if(sc->copper_queue->base_phys_addr == 0){
621 ips_write_4(sc, COPPER_REG_SQSR, sc->copper_queue->base_phys_addr);
622 ips_write_4(sc, COPPER_REG_SQER, sc->copper_queue->base_phys_addr +
623 IPS_MAX_CMD_NUM * 4);
624 ips_write_4(sc, COPPER_REG_SQHR, sc->copper_queue->base_phys_addr + 4);
625 ips_write_4(sc, COPPER_REG_SQTR, sc->copper_queue->base_phys_addr);
630 if (sc->copper_queue != NULL)
631 bus_dmamem_free(dmatag, sc->copper_queue, dmamap);
632 bus_dma_tag_destroy(dmatag);
636 /* see if we should reinitialize the card and wait for it to timeout or complete initialization FIXME */
637 int ips_copperhead_reinit(ips_softc_t *sc, int force)
640 u_int32_t postcode = 0, configstatus = 0;
641 ips_write_1(sc, COPPER_REG_SCPR, 0x80);
642 ips_write_1(sc, COPPER_REG_SCPR, 0);
643 device_printf(sc->dev, "reinitializing adapter, this could take several minutes.\n");
644 for(j = 0; j < 2; j++){
646 for(i = 0; i < 45; i++){
647 if(ips_read_1(sc, COPPER_REG_HISR) & COPPER_GHI_BIT){
648 postcode |= ips_read_1(sc, COPPER_REG_ISPR);
649 ips_write_1(sc, COPPER_REG_HISR,
658 for(j = 0; j < 2; j++){
660 for(i = 0; i < 240; i++){
661 if(ips_read_1(sc, COPPER_REG_HISR) & COPPER_GHI_BIT){
662 configstatus |= ips_read_1(sc, COPPER_REG_ISPR);
663 ips_write_1(sc, COPPER_REG_HISR,
672 for(i = 0; i < 240; i++){
673 if(!(ips_read_1(sc, COPPER_REG_CBSP) & COPPER_OP_BIT)){
680 ips_write_2(sc, COPPER_REG_CCCR, 0x1000 | COPPER_ILE_BIT);
681 ips_write_1(sc, COPPER_REG_SCPR, COPPER_EBM_BIT);
682 ips_copperhead_queue_init(sc);
683 ips_write_1(sc, COPPER_REG_HISR, COPPER_GHI_BIT);
684 i = ips_read_1(sc, COPPER_REG_SCPR);
685 ips_write_1(sc, COPPER_REG_HISR, COPPER_EI_BIT);
687 device_printf(sc->dev, "adapter initialization failed\n");
690 if(force && ips_clear_adapter(sc)){
691 device_printf(sc->dev, "adapter clear failed\n");
696 static u_int32_t ips_copperhead_cmd_status(ips_softc_t *sc)
699 int statnum = sc->copper_queue->nextstatus++;
700 if(sc->copper_queue->nextstatus == IPS_MAX_CMD_NUM)
701 sc->copper_queue->nextstatus = 0;
702 value = sc->copper_queue->status[statnum];
703 ips_write_4(sc, COPPER_REG_SQTR, sc->copper_queue->base_phys_addr +
709 void ips_copperhead_intr(void *void_sc)
711 ips_softc_t *sc = (ips_softc_t *)void_sc;
713 ips_cmd_status_t status;
715 mtx_lock(&sc->queue_mtx);
716 while(ips_read_1(sc, COPPER_REG_HISR) & COPPER_SCE_BIT){
717 status.value = ips_copperhead_cmd_status(sc);
718 cmdnumber = status.fields.command_id;
719 sc->commandarray[cmdnumber].status.value = status.value;
720 sc->commandarray[cmdnumber].timeout = 0;
721 sc->commandarray[cmdnumber].callback(&(sc->commandarray[cmdnumber]));
722 PRINTF(9, "ips: got command %d\n", cmdnumber);
724 mtx_unlock(&sc->queue_mtx);
728 void ips_issue_copperhead_cmd(ips_command_t *command)
731 /* hmmm, is there a cleaner way to do this? */
732 if(command->sc->state & IPS_OFFLINE){
733 ips_set_error(command, EINVAL);
734 command->callback(command);
737 command->timeout = 10;
738 for(i = 0; ips_read_4(command->sc, COPPER_REG_CCCR) & COPPER_SEM_BIT;
741 printf("sem bit still set, can't send a command\n");
744 DELAY(500);/* need to do a delay here */
746 ips_write_4(command->sc, COPPER_REG_CCSAR, command->command_phys_addr);
747 ips_write_2(command->sc, COPPER_REG_CCCR, COPPER_CMD_START);
750 void ips_copperhead_poll(ips_command_t *command)
753 printf("ips: cmd polling not implemented for copperhead devices\n");